Display.cpp

Go to the documentation of this file.

#include <windows.h>

#include "../include/Display.hpp"



using namespace std;

const string Display::SELECTED = "\033[1;30;46m";

const string Display::BOLD = "\033[1m";

const string Display::BLACK = "\033[30m";
const string Display::RED = "\033[31m";
const string Display::GREEN = "\033[32m";
const string Display::YELLOW = "\033[33m";
const string Display::BLUE = "\033[34m";
const string Display::MAGENTA = "\033[35m";
const string Display::CYAN = "\033[36m";
const string Display::WHITE = "\033[37m";

const string Display::BOLD_BLACK = "\033[1;30m";
const string Display::BOLD_RED = "\033[1;31m";
const string Display::BOLD_GREEN = "\033[1;32m";
const string Display::BOLD_YELLOW = "\033[1;33m";
const string Display::BOLD_BLUE = "\033[1;34m";
const string Display::BOLD_MAGENTA = "\033[1;35m";
const string Display::BOLD_CYAN = "\033[1;36m";
const string Display::BOLD_WHITE = "\033[1;37m";

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

Display::Display()
{
    _splash = "";
    _asciiBuffer = "";
    _barBuffer = "";
    _controlBuffer = "";
    _splitBuffer = "";

    _oldAscii = "";
    _oldControls = "";
    _oldSplash = "";
    _oldSplits = "";

    _fonts = {f1_ascii, f2_ascii, f3_ascii, f4_ascii};
    _fontHeights = {f1_height, f2_height, f3_height, f4_height};

    setFont(1);

    _asciiWidth = 0;
}

/* =========================================================
TERMINAL INTERACTION HELPERS
========================================================= */

void Display::clearScreen()
{
    string clearscreen = "\033[2J\033[H";

    _oldAscii = "";
    _oldControls = "";
    _oldSplash = "";
    _oldBar = "";

    fast_print(clearscreen);
}

void Display::setFont(int num)
{
    _currFont = _fonts.at(num-1);

    ASCII_HEIGHT = _fontHeights.at(num-1);
    
    if(ASCII_HEIGHT >= 8){
        PADDING = "";
        for(int i=0; i< ASCII_HEIGHT/4; i++){
            PADDING += " ";
        }
    }
    else{
        PADDING = "";
    }
}

void Display::setCursor(int row, int col)
{
    string setcursor = "\033[" + to_string(row) + ";" + to_string(col) + "H";
    fast_print(setcursor);
}

void Display::clearLine(int row)
{
    string clearline = "\033[K";
    setCursor(row, 1);
    fast_print(clearline);
}

template <typename char_type>
auto Display::fast_print(const std::basic_string<char_type> &sss) -> void
{
    HANDLE const output_handle = GetStdHandle(STD_OUTPUT_HANDLE);
    const auto char_count = static_cast<DWORD>(sss.length());
    if constexpr (std::is_same_v<char_type, char>)
        WriteConsoleA(output_handle, sss.c_str(), char_count, nullptr, nullptr);
    else
        WriteConsoleW(output_handle, sss.c_str(), char_count, nullptr, nullptr);
}

void Display::setFormat(const string& code) {
    _oldFormatting = _formatting;
    _formatting = code;
    fast_print(_formatting);
}

void Display::clearFormat(){
    _oldFormatting = _formatting;
    _formatting = "\033[0m";

    fast_print(_formatting);
}

/* =========================================================
SPLASH TEXT HELPERS
========================================================= */

void Display::setSplash(string str)
{
    _splash = "<< " + str + " >>";
}

void Display::clearSplash()
{
    _splash = "";
}

/* =========================================================
STAGE TIMER IN ASCII
========================================================= */

void Display::stageTimerDisplay(int hours, int minutes, int seconds, int tenths)
{
    string to_print = "";

    // Only display hours if there is at least 1 hour left
    if (hours != 0)
    {
        to_print += to_string(hours) + ":";
    }

    // Add leading zero to minutes if needed
    if (int(minutes / 10) != 0)
    {
        to_print += to_string(minutes) + ":";
    }
    else
    {
        to_print += "0" + to_string(minutes) + ":";
    }

    // Add leading zero to seconds if needed
    if (int(seconds / 10) != 0)
    {
        to_print += to_string(seconds);
    }
    else
    {
        to_print += "0" + to_string(seconds);
    }  

    // Build the ASCII art for the timer display
    for (int i = 0; i < ASCII_HEIGHT; i++)
    {
        string line;
        for (char ch : to_print)
        {
            if (ch == ':')
            {
                line += _currFont.at(10)[i]; // Colon character
                line += PADDING;
            }
            else if (ch == '.')
            {
                line += _currFont.at(11)[i]; // Period character
                line += PADDING;
            }
            else
            {
                line += _currFont.at(ch - '0')[i]; // Numeric character
                line += PADDING;
            }
        }
        _asciiWidth = line.length(); // Update ASCII width
        _asciiBuffer += (line + "\n");
    }
}

void Display::stageAlarmDisplay(string time){

    string to_print = "";

    int hours = stoi(time.substr(0,2));
    int minutes = stoi(time.substr(3,2));

    // Determine AM/PM and convert 24-hour format to 12-hour format
    string period = (hours >= 12) ? "pm" : "am";
    hours = hours % 12; // Convert 24-hour to 12-hour format
    if (hours == 0) { hours = 12; } // Handle the case where hour is 0 (midnight or noon)

    to_print += to_string(hours) + ":";

    // Add leading zero to minutes if needed
    if (int(minutes / 10) != 0)
    {
        to_print += to_string(minutes);
    }
    else
    {
        to_print += "0" + to_string(minutes);
    }

    // Add " am" or " pm"
    to_print += period;


    // Build the ASCII art for the alarm display
    for (int i = 0; i < ASCII_HEIGHT; i++)
    {
        string line;
        for (char ch : to_print)
        {
            if (ch == ':')
            {
                line += _currFont.at(10)[i];
                line += PADDING;
            }
            else if (ch == 'a')
            {
                line += _currFont.at(12)[i];
                line += PADDING;
            }
            else if (ch == 'p')
            {
                line += _currFont.at(13)[i];
                line += PADDING;
            }
            else if (ch == 'm')
            {
                line += _currFont.at(14)[i];
                line += PADDING;
            }
            else
            {
                line += _currFont.at(ch - '0')[i];
                line += PADDING;
            }
        }
        _asciiWidth = line.length();
        _asciiBuffer += (line + "\n");
    }
}

void Display::stageTimerBar(double percentage)
{
    int width = _asciiWidth - 2;
    int filled = (int)((percentage / 100) * width);

    string border = "";

    // Build the top and bottom borders of the bar
    border += "+";
    for (int i = 0; i < width; ++i)
    {
        border += "-";
    }
    border += "+\n";

    _barBuffer += border;

    _barBuffer += "|";

    // Fill the bar with '#' characters based on the percentage completed
    for (int i = 0; i < width; ++i)
    {
        if (i < filled)
        {
            _barBuffer += "#";
        }
        else
        {
            _barBuffer += " ";
        }
    }

    _barBuffer += "|\n";
    _barBuffer += border;
}

void Display::stageAlarmBar(double percentage)
{
    int width = _asciiWidth - 2;
    int filled = (int)((percentage / 100) * width);

    string border = "";

    // Build the top and bottom borders of the bar
    border += "+";
    for (int i = 0; i < width; ++i)
    {
        border += "-";
    }
    border += "+\n";

    _barBuffer += border;

    _barBuffer += "|";

    // Fill the bar with '#' characters based on the percentage completed
    for (int i = 0; i < width; ++i)
    {
        if (i < filled)
        {
            _barBuffer += "#";
        }
        else
        {
            _barBuffer += " ";
        }
    }

    _barBuffer += "|\n";
    _barBuffer += border;
    
}

void Display::stageArt(vector<string> art)
{
    for(int i=0; i<art.size(); ++i){
        _controlBuffer += (art.at(i) + "\n");
    }
}

/* =========================================================
STAGE STOPWATCH IN ASCII
========================================================= */

void Display::stageStopwatchDisplay(int hours, int minutes, int seconds, int hundredths)
{
    string to_print = "";

    // Only show hours if there are more than 0
    if (hours != 0)
    {
        to_print += to_string(hours) + ":";
    }

    // Show minutes with a leading zero if needed
    if (hours)
    {
        if (int(minutes / 10) != 0)
        {
            to_print += to_string(minutes) + ":";
        }
        else
        {
            to_print += "0" + to_string(minutes) + ":";
        }
    }
    else if (minutes)
    {
        to_print += to_string(minutes) + ":";
    }

    // Show seconds with a leading zero if needed
    if (hours || minutes)
    {
        if (int(seconds / 10) != 0)
        {
            to_print += to_string(seconds);
        }
        else
        {
            to_print += "0" + to_string(seconds);
        }
    }
    else
    {
        to_print += to_string(seconds);
    }

    // Show hundredths of a second if there are no hours
    if (hours == 0)
    {
        to_print += ".";
        if (int(hundredths / 10) != 0)
        {
            to_print += to_string(hundredths);
        }
        else
        {
            to_print += "0" + to_string(hundredths);
        }
    }

    // Build the ASCII art for the stopwatch display
    for (int i = 0; i < ASCII_HEIGHT; i++)
    {
        string line;
        for (char ch : to_print)
        {
            if (ch == ':')
            {
                line += _currFont.at(10)[i]; // Colon character
                line += PADDING;
            }
            else if (ch == '.')
            {
                line += _currFont.at(11)[i]; // Period character
                line += PADDING;
            }
            else
            {
                line += _currFont.at(ch - '0')[i]; // Numeric character
                line += PADDING;
            }
        }
        _asciiBuffer += (line + "\n");
    }
}

void Display::stageStopwatchSplits(vector<int> splits){
    if (!splits.empty()) {
        _splitBuffer += "  SPLITS:\n\n";
        int startIdx = (splits.size() > 10) ? splits.size() - 10 : 0;
        for (int i = startIdx; i < splits.size(); ++i) {

            int milliseconds = splits.at(i);
            int hours = milliseconds / 3600000;
            milliseconds %= 3600000;
            int minutes = milliseconds / 60000;
            milliseconds %= 60000;
            int seconds = milliseconds / 1000;
            milliseconds %= 1000;
            int hundredths = milliseconds / 10;
            string to_print = "";

            // Only show hours if there are more than 0
            if (hours != 0) {
                to_print += to_string(hours) + ":";
            }

            // Show minutes with a leading zero if needed
            if (hours) {
                if (int(minutes / 10) != 0) {
                    to_print += to_string(minutes) + ":";
                } else {
                    to_print += "0" + to_string(minutes) + ":";
                }
            } else if (minutes) {
                to_print += to_string(minutes) + ":";
            }

            // Show seconds with a leading zero if needed
            if (hours || minutes) {
                if (int(seconds / 10) != 0) {
                    to_print += to_string(seconds);
                } else {
                    to_print += "0" + to_string(seconds);
                }
            } else {
                to_print += to_string(seconds);
            }

            // Show hundredths of a second if there are no hours
            if (hours == 0) {
                to_print += ".";
                if (int(hundredths / 10) != 0) {
                    to_print += to_string(hundredths);
                } else {
                    to_print += "0" + to_string(hundredths);
                }
            }
            string fullprint = "Split " + to_string(i + 1) + ": " + to_print + "\n";
            _splitBuffer += fullprint;
        }
    } else {
        _splitBuffer = "";
    }
}

/* =========================================================
PRINTING TO TERMINAL
========================================================= */

void Display::printAscii(int row, string formatting)
{
    setFormat(formatting);

    if (_asciiBuffer != _oldAscii || _formatting != _oldFormatting)
    {
        setCursor(row, 1);
        fast_print(_asciiBuffer);
        _oldAscii = _asciiBuffer;
    }
    _asciiBuffer = "";

    clearFormat();
}

void Display::printArt(int row, string formatting)
{
    setFormat(formatting);

    if (_controlBuffer != _oldControls || _formatting != _oldFormatting)
    {
        setCursor(row, 1);
        fast_print(_controlBuffer);
        _oldControls = _controlBuffer;
    }
    _controlBuffer = "";

    clearFormat();
}

void Display::printBar(int row, string formatting)
{
    setFormat(formatting);

    if (_barBuffer != _oldBar || _formatting != _oldFormatting)
    {
        setCursor(row, 1);
        fast_print(_barBuffer);
        _oldBar = _barBuffer;
    }
    _barBuffer = "";

    clearFormat();
}

void Display::printSplash(int row, string formatting)
{
    setFormat(formatting);

    if (_splash != _oldSplash || _formatting != _oldFormatting)
    {
        clearLine(row);
        setCursor(row, 1);
        fast_print(_splash);
        _oldSplash = _splash;
    }

    clearFormat();
}

void Display::printSplits(int row, string formatting)
{
    setFormat(formatting);
    if (_splitBuffer != _oldSplits || _formatting != _oldFormatting)
    {
        setCursor(row, 1);
        fast_print(_splitBuffer);
        _oldSplits = _splitBuffer;
    }
    _splitBuffer = "";
    
    clearFormat();
}

void Display::tickTimerSetup(string to_print)
{
    auto now = std::chrono::steady_clock::now();
    auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

    bool showBar = ((millis / 500) % 2 == 0);

    _asciiBuffer.clear(); // Clear buffer before filling it with new content

    for (int i = 0; i < ASCII_HEIGHT; ++i)
    {
        string line;
        for (char ch : to_print)
        {
            if (ch == ':')
            {
                line += _currFont.at(10)[i]; // Colon character
            }
            else
            {
                line += _currFont.at(ch - '0')[i]; // Numeric character
            }
            line += PADDING;
        }
        line += showBar ? " |" : "   "; // Append progress bar indicator
        _asciiWidth = line.length();
        _asciiBuffer += (line + "\n");
    }
    stageArt(_timerSetupControls);

    printArt(1, BOLD_CYAN);
    printAscii(5, BOLD_WHITE);
    

    setCursor(1,1);

}

void Display::tickAlarmSetup(string to_print, bool isAM)
{
    auto now = std::chrono::steady_clock::now();
    auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

    int tempHeight;

    bool showBar = ((millis / 500) % 2 == 0);
    if(ASCII_HEIGHT < 4){
        tempHeight = 4;
    }
    else{
        tempHeight = ASCII_HEIGHT;
    }
    for (int i = 0; i < tempHeight; i++)
    {
        string line;
        line += BOLD_WHITE;
        for (char ch : to_print)
        {
            if (ch == ':')
            {
                line += _currFont.at(10)[i]; // Colon character
                line += PADDING;
            }
            else
            {
                line += _currFont.at(ch - '0')[i]; // Numeric character
                line += PADDING;
            }
        }

        if(showBar){
            line += " | ";
        }

        else{
            line += "   ";
        }
        
        int linesLeft = tempHeight - i;

        if(linesLeft <= 4){

            line += "  ";
            if(isAM){
                line += SELECTED;
            }
            else{
                line += BOLD_WHITE;
            }

            line += _alarmSetupAM[4-linesLeft];

            line += "\033[0m";

            line += "  ";

            if(!isAM){
                line += SELECTED;
            }
            else{
                line += BOLD_WHITE;
            }

            line += _alarmSetupPM[4-linesLeft];

            line += "\033[0m";
            
            
        }

        _asciiWidth = line.length(); // Update ASCII width
        _asciiBuffer += (line + "\n");

    }

    stageArt(_alarmSetupControls);

    printArt(1, BOLD_CYAN);

    printAscii(5,BOLD_WHITE);

    /*
    stageArt(_alarmSetupAM);

    
    if(isAM){
        printArt(ASCII_HEIGHT + 6, SELECTED);
        stageArt(_alarmSetupPM);
        printArt(ASCII_HEIGHT + 10, BOLD_WHITE);
    }
    else{
        printArt(ASCII_HEIGHT + 6, BOLD_WHITE);
        stageArt(_alarmSetupPM);
        printArt(ASCII_HEIGHT + 10, SELECTED);
    }
    */

    setCursor(1,1);

}

void Display::tickTimer(Timer &timer)
{
    auto now = std::chrono::steady_clock::now();
    auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
    bool flash = ((millis / 500) % 2 == 0);

    int remaining = timer.remainingMilliseconds();
    int hours = remaining / 3600000;
    remaining %= 3600000;
    int minutes = remaining / 60000;
    remaining %= 60000;
    int seconds = remaining / 1000;
    remaining %= 1000;
    int tenths = remaining / 100;

    stageTimerDisplay(hours, minutes, seconds, tenths);
    stageTimerBar(timer.percentElapsed());
    stageArt(_timerControls);

    string temp;
    if(!timer.isRunning()){
        if(timer.isDone() && flash){
            temp = BOLD_WHITE;
        }
        else{
            temp = BOLD_RED;
        }
    }
    else{
        temp = BOLD_WHITE;
    }

    printAscii(1, temp);
    printBar(ASCII_HEIGHT+2, temp);
    printArt(ASCII_HEIGHT+5, BOLD_CYAN);
    printSplash(ASCII_HEIGHT+8, WHITE);

    setCursor(1,1);
}

void Display::tickStopwatch(Stopwatch &stopwatch){

    int milliseconds = stopwatch.currentMilliseconds();

    int hours = milliseconds / 3600000;
    milliseconds %= 3600000;
    int minutes = milliseconds / 60000;
    milliseconds %= 60000;
    int seconds = milliseconds / 1000;
    milliseconds %= 1000;
    int hundredths = milliseconds / 10;

    stageStopwatchDisplay(hours, minutes, seconds, hundredths);
    stageArt(_stopwatchControls);
    stageStopwatchSplits(stopwatch.getSplits());

    string temp;
    if(!stopwatch.isRunning()){
        if ((stopwatch.currentMilliseconds() / 10) % 100 == 0 && stopwatch.currentMilliseconds() != 0){
            temp = BOLD_GREEN;
        }   
        else{
            temp = BOLD_RED;
        }
    }
    else{
        temp = BOLD_WHITE;
    }
    printAscii(1, temp);

    printArt(ASCII_HEIGHT+1, BOLD_CYAN);
    printSplash(ASCII_HEIGHT+4, WHITE);
    printSplits(ASCII_HEIGHT+6, WHITE);

    clearFormat();
    setCursor(1,1);

}

void Display::tickAlarm(Alarm &alarm){

    auto now = std::chrono::steady_clock::now();
    auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
    bool flash = ((millis / 500) % 2 == 0);

    string time = alarm.timeToString(alarm.getEndTime()).substr(0,5);

    stageAlarmDisplay(time);
    stageAlarmBar(alarm.percentElapsed());
    stageArt(_alarmControls);

    string temp;
    if(alarm.isDone() && flash){
        temp = BOLD_RED;
    }
    else{
        temp = BOLD_WHITE;
    }
    printAscii(1, temp);
    printBar(ASCII_HEIGHT+2, temp);

    printArt(ASCII_HEIGHT+5, BOLD_CYAN);
    printSplash(ASCII_HEIGHT+8, WHITE);
    
    clearFormat();
    setCursor(1,1);

    return;

}