Menu Class Reference

The Menu class manages the main menu and user input for the Timer Stopwatch and Alarm. More...

#include <Menu.hpp>

Collaboration diagram for Menu:

Public Member Functions
	Menu (bool testing)
	Constructs a Menu object. More...
char	getMenuInput (int &selected)
	Waits for the user to press a valid key (1 2 3 or Q) for menu selection. More...
char	getSettingsInput (int &selected)
	Waits for the user to press a valid key (1 2 3 4 or Q) for settings selection. More...
void	wait (double seconds)
	Waits for a specific duration using busy-waiting. More...
void	waitForInput ()
	Waits for any key press from the user. More...
void	checkTimerInput (Timer &timer, bool &run)
	Checks and handles user input for the Timer. More...
void	checkStopwatchInput (Stopwatch &stopwatch, bool &run)
	Checks and handles user input for the Stopwatch. More...
void	checkAlarmInput (Alarm &alarm, bool &run)
	Checks and handles user input for the Alarm. More...
void	mainMenu (int selected)
	Starts the main menu loop allowing the user to choose between Timer Stopwatch and Alarm. More...
void	settingsMenu (int selected)
	Starts the settings menu loop allowing the user to change the notification and font settings. More...
void	loadSettings ()
	Loads the notification and font settings from a file. More...
void	saveSettings ()
	Saves the notification and font settings to a file. More...
void	credits ()
	Displays the credits for the Timer Stopwatch and Alarm. More...
void	timerSequence ()
	Displays the help menu for the Timer Stopwatch and Alarm. More...
void	stopwatchSequence ()
	Displays the help menu for the Timer Stopwatch and Alarm. More...
void	alarmSequence ()
	Displays the help menu for the Timer Stopwatch and Alarm. More...
Timer	createTimer (bool &run)
	Creates a Timer object with user input for the duration. More...
Alarm	createAlarm (bool &run)
	Creates a Alarm object with user input for the duration. More...
void	printTimerInput (int, int, int)
	Prints the Timer's input duration to the console. More...
void	printArt (vector< string > art, string formatting)
	Prints the Alarm's input duration to the console. More...

Private Attributes
Display	_display
	Instance of Display to manage the visual representation. More...
bool	_run
	Boolean to control the main loop execution. More...
bool	_testing
vector< string >	_menuFormats
vector< string >	_settingsFormats
bool	_notiSetting
int	_fontSetting
vector< string >	_logoArt
vector< string >	_credits
vector< string >	_menuArt
vector< string >	_menuTimer
vector< string >	_menuStopwatch
vector< string >	_menuAlarm
vector< string >	_menuSettings
vector< string >	_menuQuit
vector< string >	_menuBlank
vector< string >	_settingsArt
vector< string >	_settingsFont1
vector< string >	_settingsFont2
vector< string >	_settingsFont3
vector< string >	_settingsFont4
vector< string >	_settingsNotiOn
vector< string >	_settingsNotiOff
vector< string >	_settingsCredits
vector< string >	_settingsBack
vector< string >	_settingsBlank
vector< string >	_stopMessages

Detailed Description

The Menu class manages the main menu and user input for the Timer Stopwatch and Alarm.

Definition at line 21 of file Menu.hpp.

Constructor & Destructor Documentation

Menu()

Menu::Menu

(

bool

testing

)

Constructs a Menu object.

Constructs a Menu object and initializes its state.

Definition at line 16 of file Menu.cpp.

References Display::BOLD_WHITE.

                      { 
    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);
}

Member Function Documentation

alarmSequence()

void Menu::alarmSequence

(

)

Displays the help menu for the Timer Stopwatch and Alarm.

Runs the alarm sequence, allowing the user to set and interact with an alarm.

Definition at line 349 of file Menu.cpp.

References Alarm::isDone(), and LOOPTIME.

                        {
    _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;
        }
    }
}

Here is the call graph for this function:

checkAlarmInput()

void Menu::checkAlarmInput	(	Alarm &	alarm,
		bool &	run
	)

Checks and handles user input for the Alarm.

This function processes user input to control the Alarm. It updates the Alarm's state based on the key pressed.

Parameters

alarm	The Alarm object to control.
run	A boolean reference that determines whether to continue the loop.

Definition at line 701 of file Menu.cpp.

                                                 {
    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;
    }
}

checkStopwatchInput()

void Menu::checkStopwatchInput	(	Stopwatch &	stopwatch,
		bool &	run
	)

Checks and handles user input for the Stopwatch.

This function processes user input to control the Stopwatch. It updates the Stopwatch's state based on the key pressed.

Parameters

stopwatch	The Stopwatch object to control.
run	A boolean reference that determines whether to continue the loop.

Definition at line 647 of file Menu.cpp.

References Stopwatch::addSplit(), Stopwatch::currentMilliseconds(), Stopwatch::isRunning(), Stopwatch::pause(), Stopwatch::reset(), and Stopwatch::resume().

                                                             {
    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;
    }
}

Here is the call graph for this function:

checkTimerInput()

void Menu::checkTimerInput	(	Timer &	timer,
		bool &	run
	)

Checks and handles user input for the Timer.

This function processes user input to control the Timer. It updates the Timer's state based on the key pressed.

Parameters

timer	The Timer object to control.
run	A boolean reference that determines whether to continue the loop.

Definition at line 599 of file Menu.cpp.

References Timer::isRunning(), Timer::pause(), Timer::remainingMilliseconds(), Timer::reset(), and Timer::resume().

                                                 {
    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;
        }
    }
}

Here is the call graph for this function:

createAlarm()

Alarm Menu::createAlarm

(

bool &

run

)

Creates a Alarm object with user input for the duration.

Creates a new Alarm object based on user input.

This function prompts the user to enter the hours minutes and seconds for the Alarm. It then creates a Alarm object with the specified duration and returns it.

Parameters

run	A boolean reference that determines whether to continue the loop.

Returns

The Alarm object created with the user's input.

Parameters

run	A reference to a boolean flag indicating whether to continue running the sequence.

Returns

An Alarm object initialized with the user's input.

Definition at line 453 of file Menu.cpp.

References LOOPTIME.

                                {
    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;
}

createTimer()

Timer Menu::createTimer

(

bool &

run

)

Creates a Timer object with user input for the duration.

Creates a new Timer object based on user input.

This function prompts the user to enter the hours minutes and seconds for the Timer. It then creates a Timer object with the specified duration and returns it.

Parameters

run	A boolean reference that determines whether to continue the loop.

Returns

Timer The Timer object created with the user's input.

Parameters

run	A reference to a boolean flag indicating whether to continue running the sequence.

Returns

A Timer object initialized with the user's input.

Definition at line 386 of file Menu.cpp.

References LOOPTIME.

                                {
    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;
}

credits()

void Menu::credits

(

)

Displays the credits for the Timer Stopwatch and Alarm.

Displays the start screen with logo art and credits.

Definition at line 58 of file Menu.cpp.

References Display::BOLD_CYAN, and Display::WHITE.

                  {
    _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();
}

getMenuInput()

char Menu::getMenuInput

(

int &

selected

)

Waits for the user to press a valid key (1 2 3 or Q) for menu selection.

Waits for the user to press a valid key (1, 2, 3, or Q) for menu selection.

This function repeatedly checks for user input until a valid menu option is pressed. It then returns the corresponding character for the selected menu option.

Returns

char The character corresponding to the user's menu selection.

Definition at line 732 of file Menu.cpp.

References LOOPTIME.

                                    {
    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
    }
}

getSettingsInput()

char Menu::getSettingsInput

(

int &

selected

)

Waits for the user to press a valid key (1 2 3 4 or Q) for settings selection.

Waits for the user to press a valid key (1, 2, 3, or Q) for settings selection.

This function repeatedly checks for user input until a valid settings option is pressed. It then returns the corresponding character for the selected settings option.

Returns

char The character corresponding to the user's settings selection.

Parameters

selected

The current selected setting.

Returns

char The character corresponding to the user's settings selection.

Definition at line 789 of file Menu.cpp.

References LOOPTIME.

                                        {
    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
    }
}

loadSettings()

void Menu::loadSettings

(

)

Loads the notification and font settings from a file.

Loads the user's settings from a file.

This function reads the font setting and notification setting from a "settings.txt" file if it exists, otherwise it uses default values.

Definition at line 85 of file Menu.cpp.

                        {
    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;
    }
}

mainMenu()

void Menu::mainMenu

(

int

selected

)

Starts the main menu loop allowing the user to choose between Timer Stopwatch and Alarm.

Starts the main menu loop, allowing the user to choose between Timer, Stopwatch, and Alarm.

The menu displays options to the user processes the user's selection and runs the appropriate sequence for Timer Stopwatch or Alarm. It handles the input and output and returns to the menu after each operation unless the user chooses to quit.

The menu displays options to the user, processes the user's selection, and runs the appropriate sequence for Timer, Stopwatch, or Alarm. It handles the input and output and returns to the menu after each operation unless the user chooses to quit.

Definition at line 127 of file Menu.cpp.

References Display::BOLD_CYAN, Display::BOLD_WHITE, and Display::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);
}

printArt()

void Menu::printArt	(	vector< string >	art,
		string	formatting
	)

Prints the Alarm's input duration to the console.

Prints ASCII art to the display with specified formatting.

This function prints the hours minutes and seconds of the Alarm's input duration to the console.

Parameters

hours	The hours of the Alarm's input duration.
minutes	The minutes of the Alarm's input duration.
seconds	The seconds of the Alarm's input duration.
art	A vector of strings representing the ASCII art.
formatting	The display format for the art.

Definition at line 45 of file Menu.cpp.

                                                        {
    _display.setFormat(formatting);

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

    _display.clearFormat();
}

printTimerInput()

void Menu::printTimerInput	(	int	,
		int	,
		int
	)

Prints the Timer's input duration to the console.

This function prints the hours minutes and seconds of the Timer's input duration to the console.

Parameters

hours	The hours of the Timer's input duration.
minutes	The minutes of the Timer's input duration.
seconds	The seconds of the Timer's input duration.

saveSettings()

void Menu::saveSettings

(

)

Saves the notification and font settings to a file.

Saves the user's settings to a file.

This function writes the font setting and notification setting to a "settings.txt" file.

Definition at line 105 of file Menu.cpp.

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

settingsMenu()

void Menu::settingsMenu

(

int

selected

)

Starts the settings menu loop allowing the user to change the notification and font settings.

Displays the settings menu and allows the user to modify settings.

The settings menu displays options to the user processes the user's selection and runs the appropriate sequence for changing the notification and font settings. It handles the input and output and returns to the settings menu after each operation unless the user chooses to quit.

The settings include font selection and notifications.

Parameters

selected

The index of the selected settings option.

Definition at line 202 of file Menu.cpp.

References Display::BOLD_CYAN, Display::BOLD_WHITE, NUM_FONTS, and Display::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);
}

stopwatchSequence()

void Menu::stopwatchSequence

(

)

Displays the help menu for the Timer Stopwatch and Alarm.

Runs the stopwatch sequence, allowing the user to start, stop, and record splits.

Definition at line 319 of file Menu.cpp.

References LOOPTIME.

                            {

    _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;
        }
    }
}

timerSequence()

void Menu::timerSequence

(

)

Displays the help menu for the Timer Stopwatch and Alarm.

Runs the timer sequence, allowing the user to set and interact with a timer.

Definition at line 284 of file Menu.cpp.

References LOOPTIME, and Timer::remainingMilliseconds().

                        {
    _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;
        }
    }
}

Here is the call graph for this function:

wait()

void Menu::wait

(

double

seconds

)

Waits for a specific duration using busy-waiting.

This function uses a high-resolution clock to wait for the specified amount of time (in seconds). It continuously checks the elapsed time until the desired duration has passed.

Parameters

seconds

The amount of time to wait in seconds.

This function uses a high-resolution clock to wait for the specified amount of time (in seconds). It continuously checks the elapsed time until the desired duration has passed.

Parameters

seconds

The amount of time to wait, in seconds.

Definition at line 566 of file Menu.cpp.

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

waitForInput()

void Menu::waitForInput

(

)

Waits for any key press from the user.

This function blocks until the user presses a key using _getch() to capture the input.

This function blocks until the user presses a key, using _getch() to capture the input.

Definition at line 580 of file Menu.cpp.

                        {
    if(_testing){
        return;
    }
    _getch();
}

Field Documentation

_credits

vector<string> Menu::_credits

private

Initial value:

= {
        "-------------------------------------", 
        "             Tempo v1.0              ", 
        "-------------------------------------", 
        "    A lightweight timer, stopwatch,", 
        "       and alarm terminal app.", 
        "-------------------------------------", 
        "            Developed by:", 
        "          William Donnelly", 
        "            Kevin Albert", 
        "            Rowan Zeszut", 
        "            Ben Sampson", 
        "-------------------------------------",
        "", 
        "    Press any key to continue...",
    }

Definition at line 218 of file Menu.hpp.

_display

Display Menu::_display

private

Instance of Display to manage the visual representation.

Definition at line 189 of file Menu.hpp.

_fontSetting

int Menu::_fontSetting

private

Definition at line 197 of file Menu.hpp.

_logoArt

vector<string> Menu::_logoArt

private

Initial value:

= {
        "                                                                                                ", 
        "    &&&&&&&&&&&&&&&&                                                                            ", 
        "    &&&&&&&&&&&&&&&                                                                             ", 
        "        &&&&&&       &&&&&&&&&&&&&   &&&&&& &&&&&&& &&&&&&&&    &&&&&&&&&&&      &&&&&&&&&&&&& ", 
        "       &&&&&%     &&&&&&&&&&&&&&&   &&&&&&&&&&&&&&&&&&&&&&&   &&&&&&&&&&&&&&&  &&&&&&&&&&&&&&&  ", 
        "      &&&&&&      &&&&&&   &&&&&&  &&&&&&   &&&&&&   &&&&&&   &&&&&&  &&&&&&   &&&&&    &&&&&&  ",
        "     &&&&&&      &&&&&&&&&&&&&&&   &&&&&&  &&&&&&&  &&&&&&   &&&&&&   &&&&&&  &&&&&&    &&&&&&   ", 
        "    &&&&&&&      &&&&&&           &&&&&&   &&&&&&   &&&&&&  &&&&&&&  &&&&&&   &&&&&&   &&&&&&   ", 
        "    &&&&&&      &&&&&&&   &&&&   &&&&&&  &&&&&&#  &&&&&&   &&&&&&&&&&&&&&&  &&&&&&&&&&&&&&&    ",
        "   &&&&&&&     %&&&&&&&&&&&&&   &&&&&&   &&&&&&  #&&&&&&   &&&&&&&&&&&&       &&&&&&&&&&&&     ",
        "                                                          &&&&&&                                ",
        "  &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&         ",
        " &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&                  ",
        "                                                                                                "
    }

Definition at line 200 of file Menu.hpp.

_menuAlarm

vector<string> Menu::_menuAlarm

private

Initial value:

= {
        " _                         _                             ", 
        " _)  o     /\\   |    /\\   |_)  |\\/|                      ", 
        " _)  o    /--\\  |_  /--\\  | \\  |  |                      ",
        "                                                         ", 
    }

Definition at line 255 of file Menu.hpp.

_menuArt

vector<string> Menu::_menuArt

private

Initial value:

= {
        "             ___                 _            ", 
        " |\\/|   /\\    |   |\\ |    |\\/|  |_  |\\ |  | | ", 
        " |  |  /--\\  _|_  | \\|    |  |  |_  | \\|  |_| ", 
        "________________________________________________",
       "",
    }

Definition at line 235 of file Menu.hpp.

_menuBlank

vector<string> Menu::_menuBlank

private

Definition at line 273 of file Menu.hpp.

_menuFormats

vector<string> Menu::_menuFormats

private

Definition at line 193 of file Menu.hpp.

_menuQuit

vector<string> Menu::_menuQuit

private

Initial value:

= {                                 
        " _         _        ___  ___                             ", 
        "/ \\  o    / \\  | |   |    |                              ", 
        "\\_X  o    \\_X  |_|  _|_   |                              ", 
        "                                                         ",
    }

Definition at line 267 of file Menu.hpp.

_menuSettings

vector<string> Menu::_menuSettings

private

Initial value:

= {
        " __       __  _ ___ ___ ___       __  __                 ", 
        "(_   o   (_  |_  |   |   |  |\\ | /__ (_                  ",  
        "__)  o   __) |_  |   |  _|_ | \\| \\_| __)                 ",
        "                                                         ",
    }

Definition at line 261 of file Menu.hpp.

_menuStopwatch

vector<string> Menu::_menuStopwatch

private

Initial value:

= {
        " _         __  ___   _    _                 ___   _      ",
        "  )  o    (_    |   / \\  |_)  \\    /   /\\    |   /   |_| ", 
        " /_  o    __)   |   \\_/  |     \\/\\/   /--\\   |   \\_  | | ",
        "                                                         ",
    }

Definition at line 249 of file Menu.hpp.

_menuTimer

vector<string> Menu::_menuTimer

private

Initial value:

= {
        "          ___  ___         _   _                         ", 
        " /|  o     |    |   |\\/|  |_  |_)                        ", 
        "  |  o     |   _|_  |  |  |_  | \\                        ",
        "                                                         ",
    }

Definition at line 243 of file Menu.hpp.

_notiSetting

bool Menu::_notiSetting

private

Definition at line 196 of file Menu.hpp.

_run

bool Menu::_run

private

Boolean to control the main loop execution.

Definition at line 190 of file Menu.hpp.

_settingsArt

vector<string> Menu::_settingsArt

private

Initial value:

= {
        "   __  _ ___ ___ ___       __  __                                            ",                                     
        "  (_  |_  |   |   |  |\\ | /__ (_                                             ",                                     
        "  __) |_  |   |  _|_ | \\| \\_| __)                                            ",                                                                 
        "____________________________________                                         ",
        "                                                                             ",
    }

Definition at line 308 of file Menu.hpp.

_settingsBack

vector<string> Menu::_settingsBack

private

Initial value:

= {                                 
        " _        _        _                                                         ", 
        "/ \\  o   |_)  /\\  /  |/                                                      ", 
        "\\_X  o   |_) /--\\ \\_ |\\                                                      ", 
        "                                                                             ",

    }

Definition at line 373 of file Menu.hpp.

_settingsBlank

vector<string> Menu::_settingsBlank

private

Definition at line 380 of file Menu.hpp.

_settingsCredits

vector<string> Menu::_settingsCredits

private

Initial value:

= {
        " _        _  _   _  _  ___ ___ __                                            ", 
        " _)  o   /  |_) |_ | \\  |   | (_                                             ", 
        " _)  o   \\_ | \\ |_ |_/ _|_  | __)                                            ",
        "                                                                             ", 
    }

Definition at line 367 of file Menu.hpp.

_settingsFont1

vector<string> Menu::_settingsFont1

private

Initial value:

= {
        "                                                      $$\\                    ", 
        "                                                    $$$$ |                   ", 
        "          _  ___  __ ___ ___    _  _      ___       \\_$$ |                   ",
        " /|  o   | \\  |  /__  |   |    |_ / \\ |\\ | |    __    $$ |                   ",
        "  |  o   |_/ _|_ \\_| _|_  |    |  \\_/ | \\| |          $$ |                   ",
        "                                                      $$ |                   ",
        "                                                    $$$$$$\\                  ",
        "                                                    \\______|                 ",
        
    }

Definition at line 316 of file Menu.hpp.

_settingsFont2

vector<string> Menu::_settingsFont2

private

Initial value:

= {
        "          _  ___  __ ___ ___    _  _      ___        _                       ", 
        " /|  o   | \\  |  /__  |   |    |_ / \\ |\\ | |    __    )                      ", 
        "  |  o   |_/ _|_ \\_| _|_  |    |  \\_/ | \\| |         /_                      ",
        "                                                                             ",
    }

Definition at line 327 of file Menu.hpp.

_settingsFont3

vector<string> Menu::_settingsFont3

private

Initial value:

= {
        "                                                       .--.                  ", 
        "                                                     /     \\                 ", 
        "                                                    (___)`. |                ",
        "          _  ___  __ ___ ___    _  _      ___           .-' /                ",
        " /|  o   | \\  |  /__  |   |    |_ / \\ |\\ | |    __      '. \\                 ",
        "  |  o   |_/ _|_ \\_| _|_  |    |  \\_/ | \\| |         ___ \\ '                 ",
        "                                                    (   ) ; |                ",
        "                                                     \\ `-'  /                ",
        "                                                      ',__.'                 ",
    }

Definition at line 333 of file Menu.hpp.

_settingsFont4

vector<string> Menu::_settingsFont4

private

Initial value:

= {
        "                                                        d8888                ", 
        "                                                       d8P888                ", 
        "          _  ___  __ ___ ___    _  _      ___         d8P 888                ",
        " /|  o   | \\  |  /__  |   |    |_ / \\ |\\ | |    __   d8P  888                ",
        "  |  o   |_/ _|_ \\_| _|_  |    |  \\_/ | \\| |        d88   888                ",
        "                                                    8888888888               ",
        "                                                          888                ",
        "                                                          888                ", 
    }

Definition at line 344 of file Menu.hpp.

_settingsFormats

vector<string> Menu::_settingsFormats

private

Definition at line 194 of file Menu.hpp.

_settingsNotiOff

vector<string> Menu::_settingsNotiOff

private

Initial value:

= {
        " _             _ ___ ___  _ ___  _     ___ ___  _        __         _   _  _ ",
        "  )  o   |\\ | / \\ |   |  |_  |  /   /\\  |   |  / \\ |\\ | (_    __   / \\ |_ |_ ", 
        " /_  o   | \\| \\_/ |  _|_ |  _|_ \\_ /--\\ |  _|_ \\_/ | \\| __)        \\_/ |  |  ",
        "                                                                             ",
    }

Definition at line 361 of file Menu.hpp.

_settingsNotiOn

vector<string> Menu::_settingsNotiOn

private

Initial value:

= {
        " _             _ ___ ___  _ ___  _     ___ ___  _        __         _        ",
        "  )  o   |\\ | / \\ |   |  |_  |  /   /\\  |   |  / \\ |\\ | (_    __   / \\ |\\ |  ", 
        " /_  o   | \\| \\_/ |  _|_ |  _|_ \\_ /--\\ |  _|_ \\_/ | \\| __)        \\_/ | \\|  ",
        "                                                                             ",
    }

Definition at line 355 of file Menu.hpp.

_stopMessages

vector<string> Menu::_stopMessages

private

Initial value:

= {
        "EXACTLY ON THE DOT! YOU MUST BE A TIME WIZARD.", 
        "THERE'S NO WAY YOU MEANT TO DO THAT...", 
        "YOU'VE ACHIEVED STOPWATCH ZEN.", 
        "IF YOU DID THAT ON PURPOSE, I'M IMPRESSED.", 
        "DAMN, NICE REFLEXES.", 
        "YOU'RE A MEAN GREEN STOPWATCH MACHINE.", 
        "MEAN GREEN STOPWATCH MACHINE", 
        "YOU HAVE TO BE A ROBOT, RIGHT?", 
        "EVEN QUICKSILVER COULDN'T HAVE DONE IT BETTER.",
        "YOU ARE A BUM, GO HOME LOSER!!!!"
    }

Definition at line 415 of file Menu.hpp.

_testing

bool Menu::_testing

private

Definition at line 191 of file Menu.hpp.

---

The documentation for this class was generated from the following files:

• include/Menu.hpp
• src/Menu.cpp