console.cpp

/* This file is part of the "ST" project.
 * You may use, distribute or modify this code under the terms
 * of the GNU General Public License version 2.
 * See LICENCE.txt in the root directory of the project.
 *
 * Author: Maxim Atanasov
 * E-mail: maxim.atanasov@protonmail.com
 */
 
#include <console.hpp>
#include <key_definitions.hpp>
 
static bool singleton_initialized = false;
 
console::console(message_bus &gMessageBus) : gMessage_bus(gMessageBus) {
    if (singleton_initialized) {
        throw std::runtime_error("The dev console cannot be initialized more than once!");
    } else {
        singleton_initialized = true;
    }
 
    color = {50, 50, 50, 100};
    color_text = {255, 255, 255, 255};
    color_info = {10, 50, 255, 255};
    color_error = {255, 0, 0, 255};
    color_success = {50, 255, 10, 255};
    shown = false;
    scroll_offset = 0;
    gMessage_bus.subscribe(LOG_ERROR, &msg_sub);
    gMessage_bus.subscribe(LOG_SUCCESS, &msg_sub);
    gMessage_bus.subscribe(LOG_INFO, &msg_sub);
    gMessage_bus.subscribe(CONSOLE_TOGGLE, &msg_sub);
    gMessage_bus.subscribe(MOUSE_SCROLL, &msg_sub);
    gMessage_bus.subscribe(KEY_PRESSED, &msg_sub);
    gMessage_bus.subscribe(KEY_HELD, &msg_sub);
    gMessage_bus.subscribe(KEY_RELEASED, &msg_sub);
    gMessage_bus.subscribe(TEXT_STREAM, &msg_sub);
    gMessage_bus.subscribe(CONSOLE_CLEAR, &msg_sub);
}
 
void console::post_init() const {
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::ENTER)));
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::TILDE)));
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::LEFT)));
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::RIGHT)));
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::UP)));
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::DOWN)));
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::BACKSPACE)));
    gMessage_bus.send_msg(new message(REGISTER_KEY, static_cast<uint8_t>(ST::key::DELETE)));
}
 
 
void console::scroll(int32_t scroll_y) {
    scroll_offset = scroll_y * 20;
}
 
void console::handle_messages() {
    message *temp = msg_sub.get_next_message();
    while (temp != nullptr) {
        switch (temp->msg_name) {
            case LOG_ERROR: {
                auto log = static_cast<std::string *>(temp->get_data());
                if (log_level == 0x07 || log_level == 0x01 || log_level == 0x03 || log_level == 0x05) {
                    write(*log, ST::log_type::ERROR);
                }
                break;
            }
            case LOG_INFO: {
                auto log = static_cast<std::string *>(temp->get_data());
                if (log_level >= 0x04) {
                    write(*log, ST::log_type::INFO);
                }
                break;
            }
            case LOG_SUCCESS: {
                auto log = static_cast<std::string *>(temp->get_data());
                if (log_level >= 0x06 || log_level == 0x02 || log_level == 0x03) {
                    write(*log, ST::log_type::SUCCESS);
                }
                break;
            }
            case CONSOLE_TOGGLE:
                toggle();
                break;
            case CONSOLE_CLEAR:
                this->entries.clear();
                break;
            case MOUSE_SCROLL:
                scroll(static_cast<int32_t>(temp->base_data0));
                break;
            case KEY_HELD: {
                auto key_val = static_cast<ST::key>(temp->base_data0);
                if (is_open()) {
                    cursor_timer = 0; //Cursor won't blink when holding these keys
                    if (hold_counter > 10) { //These values can be changed to adjust the key hold delay.
                        hold_counter = 9;
                        if (key_val == ST::key::ENTER) {
                            enterKeyAction();
                        } else if (key_val == ST::key::LEFT) {
                            leftKeyAction();
                        } else if (key_val == ST::key::RIGHT) {
                            rightKeyAction();
                        } else if (key_val == ST::key::UP) {
                            upKeyAction();
                        } else if (key_val == ST::key::DOWN) {
                            downKeyAction();
                        } else if (key_val == ST::key::BACKSPACE) {
                            backspaceAction();
                        } else if (key_val == ST::key::DELETE) {
                            deleteKeyAction();
                        }
                    } else {
                        ++hold_counter;
                    }
                }
                break;
            }
            case KEY_PRESSED: {
                auto key_val = static_cast<ST::key>(temp->base_data0);
                if (key_val == ST::key::TILDE) {
                    toggle();
                } else if (is_open()) {
                    if (key_val == ST::key::ENTER) {
                        enterKeyAction();
                    } else if (key_val == ST::key::LEFT) {
                        leftKeyAction();
                    } else if (key_val == ST::key::RIGHT) {
                        rightKeyAction();
                    } else if (key_val == ST::key::UP) {
                        upKeyAction();
                    } else if (key_val == ST::key::DOWN) {
                        downKeyAction();
                    } else if (key_val == ST::key::BACKSPACE) {
                        backspaceAction();
                    } else if (key_val == ST::key::DELETE) {
                        deleteKeyAction();
                    }
                    hold_counter = 0;
                }
                break;
            }
            case TEXT_STREAM: {
                std::string received_data = *static_cast<std::string *>(temp->get_data());
                for (char const &c: received_data) {
                    if (c > 126 || c < 0) {
                        received_data.clear();
                    }
                }
                if (received_data == "(") {
                    received_data += ")";
                    composition.insert(cursor_position--, received_data);
                } else if (received_data == "\"") {
                    received_data += received_data;
                    composition.insert(cursor_position--, received_data);
                } else if (received_data == "[" || received_data == "{") {
                    received_data += static_cast<char>(received_data.at(0) + 2);
                    composition.insert(cursor_position--, received_data);
                } else {
                    composition.insert(cursor_position, received_data);
                }
                cursor_position += static_cast<uint16_t>(received_data.size());
                gMessage_bus.send_msg(new message(CLEAR_TEXT_STREAM));
                break;
            }
        }
        delete temp;
        temp = msg_sub.get_next_message();
    }
}
 
void console::set_log_level(ST::log_type arg) {
    log_level = static_cast<uint8_t>(arg);
}
 
void console::toggle() {
    if (is_open()) {
        hide();
        gMessage_bus.send_msg(new message(STOP_TEXT_INPUT));
    } else {
        show();
        gMessage_bus.send_msg(new message(START_TEXT_INPUT));
    }
}
 
void console::write(const std::string &arg, ST::log_type type) {
    if (type == ST::log_type::ERROR) {
        fprintf(stderr, "%s\n", arg.c_str());
    } else {
        fprintf(stdout, "%s\n", arg.c_str());
    }
    entries.emplace_back(type, arg);
    //remove an entry if there are too many
    if (entries.size() > 1000) {
        entries.erase(entries.begin());
    }
}
 
bool console::is_open() const {
    return shown;
}
 
void console::hide() {
    shown = false;
}
 
void console::show() {
    shown = true;
}
 
console::~console() {
    singleton_initialized = false;
}
 
void console::backspaceAction() {
    if (cursor_position > 0) {
        composition.erase(static_cast<uint16_t>(cursor_position - 1), 1);
        cursor_position -= 1;
    }
}
 
void console::rightKeyAction() {
    if (cursor_position < composition.size()) {
        cursor_position += 1;
    }
}
 
void console::leftKeyAction() {
    if (cursor_position > 0) {
        cursor_position -= 1;
    }
}
 
void console::downKeyAction() {
    if (entries_history_index < command_entries.size() - 1) {
        entries_history_index++;
        composition = command_entries.at(static_cast<uint64_t>(entries_history_index));
    } else {
        entries_history_index = -1;
        composition = composition_history_temp;
    }
    gMessage_bus.send_msg(new message(CLEAR_TEXT_STREAM));
    cursor_position = static_cast<uint16_t>(composition.size());
}
 
void console::upKeyAction() {
    if (entries_history_index == -1 && !command_entries.empty()) {
        composition_history_temp = composition;
        composition = command_entries.back();
        entries_history_index = static_cast<int16_t>(command_entries.size() - 1);
    } else if (entries_history_index > 0) {
        entries_history_index--;
        composition = command_entries.at(static_cast<uint64_t>(entries_history_index));
    }
    gMessage_bus.send_msg(new message(CLEAR_TEXT_STREAM));
    cursor_position = static_cast<uint16_t>(composition.size());
}
 
void console::enterKeyAction() {
    if (!composition.empty()) {
        write(composition, ST::log_type::INFO);
        command_entries.emplace_back(composition);
        gMessage_bus.send_msg(new message(EXECUTE_SCRIPT, make_data(composition)));
    }
    composition.clear();
    cursor_position = 0;
    entries_history_index = -1;
    gMessage_bus.send_msg(new message(CLEAR_TEXT_STREAM));
}
 
void console::deleteKeyAction() {
    composition.erase(cursor_position, 1);
}
 
void console::update() {
    handle_messages();
}