Swap to just priming file on button click, status display

2 files changed, 343 insertions, 316 deletions

diff --git a/gui/gui.cc b/gui/gui.cc
index 9381b55..5848c65 100644
--- a/gui/gui.cc
+++ b/gui/gui.cc
@@ -1,284 +1,308 @@
 #include "gui.h"
 #include "./ui_gui.h"
+#include "messages.h"
 
-GUI::GUI(QWidget *parent)
-    : QMainWindow(parent)
-    , ui(new Ui::GUI)
+GUI::GUI(QWidget *parent) : QMainWindow(parent), ui(new Ui::GUI)
 {
-    ui->setupUi(this);
+	ui->setupUi(this);
 
-		QLabel* status_label = new QLabel("CONSENSUS: WAITING FOR USER.", this);
-		QLabel* risc_vector = new QLabel("RISC V[ECTOR], CS535 UMASS AMHERST", this);
-		status_label->setMinimumWidth(1200);
-		ui->statusBar->addWidget(status_label);
-		ui->statusBar->addPermanentWidget(risc_vector);
+	this->status_label = new QLabel(this->make_status(get_waiting), this);
+	QLabel *risc_vector =
+		new QLabel("RISC V[ECTOR], CS535 UMASS AMHERST", this);
+	status_label->setMinimumWidth(1200);
+	ui->statusBar->addWidget(status_label);
+	ui->statusBar->addPermanentWidget(risc_vector);
 
-    worker = new Worker();
-    worker->moveToThread(&workerThread);
+	worker = new Worker();
+	worker->moveToThread(&workerThread);
 
-    // Connect worker thread lifecycle
-    // connect(&workerThread, &QThread::started, worker, &Worker::doWork);
+	// Connect worker thread lifecycle
+	// connect(&workerThread, &QThread::started, worker, &Worker::doWork);
 
-    // display clock cycles and PC
-    connect(worker, &Worker::clock_cycles, this, &GUI::onWorkerClockCycles);
+	// display clock cycles and PC
+	connect(worker, &Worker::clock_cycles, this, &GUI::onWorkerClockCycles);
 
-    connect(worker, &Worker::if_info, this, &GUI::onWorkerFetchInfo);
+	connect(worker, &Worker::if_info, this, &GUI::onWorkerFetchInfo);
 
-    connect(worker, &Worker::id_info, this, &GUI::onWorkerDecodeInfo);
+	connect(worker, &Worker::id_info, this, &GUI::onWorkerDecodeInfo);
 
-    connect(worker, &Worker::ex_info, this, &GUI::onWorkerExecuteInfo);
+	connect(worker, &Worker::ex_info, this, &GUI::onWorkerExecuteInfo);
 
-    connect(worker, &Worker::mm_info, this, &GUI::onWorkerMemoryInfo);
+	connect(worker, &Worker::mm_info, this, &GUI::onWorkerMemoryInfo);
 
-    connect(worker, &Worker::wb_info, this, &GUI::onWorkerWriteBackInfo);
+	connect(worker, &Worker::wb_info, this, &GUI::onWorkerWriteBackInfo);
 
-    // Display dram
-    connect(worker, &Worker::dram_storage, this, &GUI::onWorkerShowDram);
+	// Display dram
+	connect(worker, &Worker::dram_storage, this, &GUI::onWorkerShowDram);
 
-    // Display cache
-    connect(worker, &Worker::cache_storage, this, &GUI::onWorkerShowCache);
+	// Display cache
+	connect(worker, &Worker::cache_storage, this, &GUI::onWorkerShowCache);
 
-    // Display registers
-    connect(worker, &Worker::register_storage, this, &GUI::onWorkerShowRegisters);
+	// Display registers
+	connect(
+		worker, &Worker::register_storage, this, &GUI::onWorkerShowRegisters);
 
-    // // Refresh DRAM from worker thread
-    // connect(this, &GUI::sendRefreshDram, worker, &Worker::refreshDram, Qt::QueuedConnection);
+	// // Refresh DRAM from worker thread
+	// connect(this, &GUI::sendRefreshDram, worker, &Worker::refreshDram,
+	// Qt::QueuedConnection);
 
-    // // Refresh Cache from worker thread
-    // connect(this, &GUI::sendRefreshCache, worker, &Worker::refreshCache, Qt::QueuedConnection);
+	// // Refresh Cache from worker thread
+	// connect(this, &GUI::sendRefreshCache, worker, &Worker::refreshCache,
+	// Qt::QueuedConnection);
 
-    // Refresh Registers from worker thread
-    connect(this, &GUI::sendRefreshRegisters, worker, &Worker::refreshRegisters, Qt::QueuedConnection);
+	// Refresh Registers from worker thread
+	connect(
+		this, &GUI::sendRefreshRegisters, worker, &Worker::refreshRegisters,
+		Qt::QueuedConnection);
 
-    // Advance controller by somes steps
-    connect(this, &GUI::sendRunSteps, worker, &Worker::runSteps, Qt::QueuedConnection);
+	// Advance controller by somes steps
+	connect(
+		this, &GUI::sendRunSteps, worker, &Worker::runSteps,
+		Qt::QueuedConnection);
 
-    // Update the step button with step amount
-    connect(ui->step_slider, &QSlider::valueChanged, this, [=](int index){
-      int value = step_values[index];
-      ui->step_btn->setText(QString("Step %1").arg(value));
-    });
+	// Update the step button with step amount
+	connect(ui->step_slider, &QSlider::valueChanged, this, [=](int index) {
+		int value = step_values[index];
+		ui->step_btn->setText(QString("Step %1").arg(value));
+	});
 
-    // Proper cleanup when worker finishes
-    connect(worker, &Worker::finished, this, &GUI::onWorkerFinished);
-    connect(worker, &Worker::finished, &workerThread, &QThread::quit);
-    connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
+	// Proper cleanup when worker finishes
+	connect(worker, &Worker::finished, this, &GUI::onWorkerFinished);
+	connect(worker, &Worker::finished, &workerThread, &QThread::quit);
+	connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
 
-    workerThread.start(); // Start the worker thread
+	workerThread.start(); // Start the worker thread
 }
 
 GUI::~GUI()
 {
-    workerThread.quit();
-    workerThread.wait();  // Ensure proper cleanup
-    delete ui;
+	workerThread.quit();
+	workerThread.wait(); // Ensure proper cleanup
+	delete ui;
 }
 
-void displayArrayHTML(QTextEdit *textEdit, const std::array<int, GPR_NUM> &data) {
-    textEdit->setReadOnly(false);
-    QString tableText = "<table border='1' cellspacing='0' cellpadding='8' style='border-collapse: collapse; width: 100%; border: 2px solid black;'>";
-
-    tableText += "<tr>";
-    int index = 0;
-    for (int value : data) {
-        tableText += QString("<td align='center' style='border: 2px solid black; min-width: 60px; padding: 10px;'>"
-                             "%1 <sup style='font-size: 10px; font-weight: bold; color: black;'>%2</sup>"
-                             "</td>")
-                     .arg(QString::asprintf("%04X", value))
-                     .arg(index);
-        index++;
-    }
-    tableText += "</tr>";
-    tableText += "</table>";
-
-    textEdit->setHtml(tableText);
-    textEdit->setReadOnly(true);
-}
-
-void displayTableHTML(QTextEdit *textEdit, const std::vector<std::array<signed int, LINE_SIZE>> &data) {
-    textEdit->setReadOnly(false);
-    QString tableText = "<table border='1' cellspacing='0' cellpadding='8' style='border-collapse: collapse; width: 100%; border: 2px solid black;'>";
-
-    int index = 0;
-    for (const auto &row : data) {
-        tableText += "<tr>";
-        for (signed int value : row) {
-            tableText += QString("<td align='center' style='border: 2px solid black; min-width: 60px; padding: 10px;'>"
-                                 "%1 <sup style='font-size: 10px; font-weight: bold; color: black;'>%2</sup>"
-                                 "</td>")
-                         .arg(QString::asprintf("%04X", value))
-                         .arg(index);
-            index++;
-        }
-        tableText += "</tr>";
-    }
-
-    tableText += "</table>";
-
-    textEdit->setHtml(tableText);
-    textEdit->setReadOnly(true);
+void displayArrayHTML(QTextEdit *textEdit, const std::array<int, GPR_NUM> &data)
+{
+	textEdit->setReadOnly(false);
+	QString tableText = "<table border='1' cellspacing='0' cellpadding='8' "
+						"style='border-collapse: collapse; width: 100%; "
+						"border: 2px solid black;'>";
+
+	tableText += "<tr>";
+	int index = 0;
+	for (int value : data) {
+		tableText += QString("<td align='center' style='border: 2px solid "
+							 "black; min-width: 60px; padding: 10px;'>"
+							 "%1 <sup style='font-size: 10px; font-weight: "
+							 "bold; color: black;'>%2</sup>"
+							 "</td>")
+						 .arg(QString::asprintf("%04X", value))
+						 .arg(index);
+		index++;
+	}
+	tableText += "</tr>";
+	tableText += "</table>";
+
+	textEdit->setHtml(tableText);
+	textEdit->setReadOnly(true);
 }
 
-std::vector<signed int> browseAndRetrieveFile(QWidget* parent) {
-    QString filePath = QFileDialog::getOpenFileName(parent, "Open Binary File", QDir::homePath(), "Binary Files (*.bin *.rv);;All Files (*.*)");
-    std::vector<signed int> program;
-
-
-    if (filePath.isEmpty()) return program;
-
-    QFile file(filePath);
-    if (!file.open(QIODevice::ReadOnly)) {
-        QMessageBox::critical(parent, "File Upload", "Unable to open file!");
-        return program;
-    }
-
-    while (!file.atEnd()) {
-        char bytes[4];
-        if (file.read(bytes, 4) == 4) {
-            uint32_t word =
-                (static_cast<uint8_t>(bytes[0]) << 24) |
-                (static_cast<uint8_t>(bytes[1]) << 16) |
-                (static_cast<uint8_t>(bytes[2]) << 8)  |
-                (static_cast<uint8_t>(bytes[3]));
-
-            program.push_back(static_cast<signed int>(word));
-        }
-    }
-
-    file.close();
-    return program;
+void displayTableHTML(
+	QTextEdit *textEdit,
+	const std::vector<std::array<signed int, LINE_SIZE>> &data)
+{
+	textEdit->setReadOnly(false);
+	QString tableText = "<table border='1' cellspacing='0' cellpadding='8' "
+						"style='border-collapse: collapse; width: 100%; "
+						"border: 2px solid black;'>";
+
+	int index = 0;
+	for (const auto &row : data) {
+		tableText += "<tr>";
+		for (signed int value : row) {
+			tableText += QString("<td align='center' style='border: 2px solid "
+								 "black; min-width: 60px; padding: 10px;'>"
+								 "%1 <sup style='font-size: 10px; font-weight: "
+								 "bold; color: black;'>%2</sup>"
+								 "</td>")
+							 .arg(QString::asprintf("%04X", value))
+							 .arg(index);
+			index++;
+		}
+		tableText += "</tr>";
+	}
+
+	tableText += "</table>";
+
+	textEdit->setHtml(tableText);
+	textEdit->setReadOnly(true);
 }
 
-void GUI::onWorkerClockCycles(int cycles, int pc) {
-    QFont font = ui->cycles_label->font();
-    font.setBold(true);
-    font.setItalic(true);
-    font.setPointSize(14);
-    ui->cycles_label->setFont(font);
-    ui->cycles_label->setText("Clock Cycles: " + QString::number(cycles) + "\t\t" + "PC: " + QString::number(pc));
+void GUI::onWorkerClockCycles(int cycles, int pc)
+{
+	QFont font = ui->cycles_label->font();
+	font.setBold(true);
+	font.setItalic(true);
+	font.setPointSize(14);
+	ui->cycles_label->setFont(font);
+	ui->cycles_label->setText(
+		"Clock Cycles: " + QString::number(cycles) + "\t\t" +
+		"PC: " + QString::number(pc));
 }
 
-void GUI::onWorkerFetchInfo(const std::vector<int> info) {
-    if (!info.empty()) {
-        ui->fetch_squashed->setText(QString::number(info[0]));
-        ui->fetch_bits->setText(QString::asprintf("%04X", info[1]));
-    } else {
-        ui->fetch_squashed->clear();
-        ui->fetch_bits->clear();
-    }
+void GUI::onWorkerFetchInfo(const std::vector<int> info)
+{
+	if (!info.empty()) {
+		ui->fetch_squashed->setText(QString::number(info[0]));
+		ui->fetch_bits->setText(QString::asprintf("%04X", info[1]));
+	} else {
+		ui->fetch_squashed->clear();
+		ui->fetch_bits->clear();
+	}
 }
 
-void GUI::onWorkerDecodeInfo(const std::vector<int> info) {
-    if(!info.empty()) {
-        ui->decode_squashed->setText(QString::number(info[0]));
-        ui->decode_bits->setText(QString::asprintf("%04X", info[1]));
-    } else {
-        ui->decode_squashed->clear();
-        ui->decode_bits->clear();
-    }
+void GUI::onWorkerDecodeInfo(const std::vector<int> info)
+{
+	if (!info.empty()) {
+		ui->decode_squashed->setText(QString::number(info[0]));
+		ui->decode_bits->setText(QString::asprintf("%04X", info[1]));
+	} else {
+		ui->decode_squashed->clear();
+		ui->decode_bits->clear();
+	}
 }
 
-void GUI::onWorkerExecuteInfo(const std::vector<int> info) {
-    if(!info.empty()) {
-				ui->execute_mnemonic->setText(mnemonicToString((Mnemonic)info[0]));
-        ui->execute_squashed->setText(QString::number(info[1]));
-        ui->execute_s1->setText(QString::asprintf("%04X", info[2]));
-        ui->execute_s2->setText(QString::asprintf("%04X", info[3]));
-        ui->execute_s3->setText(QString::asprintf("%04X", info[4]));
-    } else {
-        ui->execute_mnemonic->clear();
-        ui->execute_squashed->clear();
-        ui->execute_s1->clear();
-        ui->execute_s2->clear();
-        ui->execute_s3->clear();
-    }
+void GUI::onWorkerExecuteInfo(const std::vector<int> info)
+{
+	if (!info.empty()) {
+		ui->execute_mnemonic->setText(mnemonicToString((Mnemonic)info[0]));
+		ui->execute_squashed->setText(QString::number(info[1]));
+		ui->execute_s1->setText(QString::asprintf("%04X", info[2]));
+		ui->execute_s2->setText(QString::asprintf("%04X", info[3]));
+		ui->execute_s3->setText(QString::asprintf("%04X", info[4]));
+	} else {
+		ui->execute_mnemonic->clear();
+		ui->execute_squashed->clear();
+		ui->execute_s1->clear();
+		ui->execute_s2->clear();
+		ui->execute_s3->clear();
+	}
 }
 
-void GUI::onWorkerMemoryInfo(const std::vector<int> info) {
-    if(!info.empty()) {
-				ui->memory_mnemonic->setText(mnemonicToString((Mnemonic)info[0]));
-        ui->memory_squashed->setText(QString::number(info[1]));
-        ui->memory_s1->setText(QString::asprintf("%04X", info[2]));
-        ui->memory_s2->setText(QString::asprintf("%04X", info[3]));
-        ui->memory_s3->setText(QString::asprintf("%04X", info[4]));
-    } else {
-        ui->memory_mnemonic->clear();
-        ui->memory_squashed->clear();
-        ui->memory_s1->clear();
-        ui->memory_s2->clear();
-        ui->memory_s3->clear();
-    }
+void GUI::onWorkerMemoryInfo(const std::vector<int> info)
+{
+	if (!info.empty()) {
+		ui->memory_mnemonic->setText(mnemonicToString((Mnemonic)info[0]));
+		ui->memory_squashed->setText(QString::number(info[1]));
+		ui->memory_s1->setText(QString::asprintf("%04X", info[2]));
+		ui->memory_s2->setText(QString::asprintf("%04X", info[3]));
+		ui->memory_s3->setText(QString::asprintf("%04X", info[4]));
+	} else {
+		ui->memory_mnemonic->clear();
+		ui->memory_squashed->clear();
+		ui->memory_s1->clear();
+		ui->memory_s2->clear();
+		ui->memory_s3->clear();
+	}
 }
 
-void GUI::onWorkerWriteBackInfo(const std::vector<int> info) {
-    if(!info.empty()) {
-				ui->write_mnemonic->setText(mnemonicToString((Mnemonic)info[0]));
-        ui->write_s1->setText(QString::asprintf("%04X", info[2]));
-        ui->write_s2->setText(QString::asprintf("%04X", info[3]));
-        ui->write_s3->setText(QString::asprintf("%04X", info[4]));
-    } else {
-        ui->write_mnemonic->clear();
-        ui->write_s1->clear();
-        ui->write_s2->clear();
-        ui->write_s3->clear();
-    }
+void GUI::onWorkerWriteBackInfo(const std::vector<int> info)
+{
+	if (!info.empty()) {
+		ui->write_mnemonic->setText(mnemonicToString((Mnemonic)info[0]));
+		ui->write_s1->setText(QString::asprintf("%04X", info[2]));
+		ui->write_s2->setText(QString::asprintf("%04X", info[3]));
+		ui->write_s3->setText(QString::asprintf("%04X", info[4]));
+	} else {
+		ui->write_mnemonic->clear();
+		ui->write_s1->clear();
+		ui->write_s2->clear();
+		ui->write_s3->clear();
+	}
 }
 
-void GUI::onWorkerShowDram(const std::vector<std::array<signed int, LINE_SIZE>> data) {
-    displayTableHTML(ui->dram_table, data);
+void GUI::onWorkerShowDram(
+	const std::vector<std::array<signed int, LINE_SIZE>> data)
+{
+	displayTableHTML(ui->dram_table, data);
 }
 
-void GUI::onWorkerShowCache(const std::vector<std::array<signed int, LINE_SIZE>> data) {
-    displayTableHTML(ui->cache_table, data);
+void GUI::onWorkerShowCache(
+	const std::vector<std::array<signed int, LINE_SIZE>> data)
+{
+	displayTableHTML(ui->cache_table, data);
 }
 
-void GUI::onWorkerShowRegisters(const std::array<int, GPR_NUM> &data) {
-    displayArrayHTML(ui->register_table, data);
+void GUI::onWorkerShowRegisters(const std::array<int, GPR_NUM> &data)
+{
+	displayArrayHTML(ui->register_table, data);
 }
 
-void GUI::onWorkerFinished() {
-    qDebug() << "Worker has finished processing.";
-}
+void GUI::onWorkerFinished() { qDebug() << "Worker has finished processing."; }
 
 void GUI::on_upload_intructions_btn_clicked()
 {
-    qDebug() << "Upload intructions button clicked.";
-    std::vector<signed int> program;
-    program = browseAndRetrieveFile(ui->register_table);
-    if(program.empty()){
-        QMessageBox::critical(ui->register_table, "File Upload", "Invalid Program File!");
-    }
-    emit sendLoadProgram(program);
-    emit sendRefreshDram();
-    QMessageBox::information(ui->register_table, "File Upload", "Instructions loaded successfully!");
+	qDebug() << "Upload intructions button clicked.";
+
+	// why register_table?
+	QString filePath = QFileDialog::getOpenFileName(
+		ui->register_table, "Open Binary File", QDir::homePath(),
+		"Binary Files (*.bin *.rv);;All Files (*.*)");
+	QFile file(filePath);
+	if (filePath.isEmpty() || !file.open(QIODevice::ReadOnly)) {
+		this->status_label->setText(this->make_status(get_bad_file));
+		return;
+	}
+
+	while (!file.atEnd()) {
+		char bytes[4];
+		if (file.read(bytes, 4) == 4) {
+			uint32_t word = (static_cast<uint8_t>(bytes[0]) << 24) |
+							(static_cast<uint8_t>(bytes[1]) << 16) |
+							(static_cast<uint8_t>(bytes[2]) << 8) |
+							(static_cast<uint8_t>(bytes[3]));
+
+			this->p.push_back(static_cast<signed int>(word));
+		}
+	}
+
+	this->status_label->setText(this->make_status(get_load_file));
+
+	file.close();
 }
 
 void GUI::on_upload_program_state_btn_clicked()
 {
-    //TODO:Upload and set program state ( have to decide how to use this)
-    qDebug() << "upload program state button is clicked.";
+	// TODO:Upload and set program state ( have to decide how to use this)
+	qDebug() << "upload program state button is clicked.";
 }
 
-void GUI::on_enable_pipeline_checkbox_checkStateChanged(const Qt::CheckState &arg1)
+void GUI::on_enable_pipeline_checkbox_checkStateChanged(
+	const Qt::CheckState &arg1)
 {
-    if(arg1 == Qt::CheckState::Checked) {
-        qDebug() << "enable pipeline checkbox checked.";
-        is_pipelined = true;
-    } else {
-        qDebug() << "enable pipeline checkbox unchecked.";
-        is_pipelined = false;
-    }
+	if (arg1 == Qt::CheckState::Checked) {
+		qDebug() << "enable pipeline checkbox checked.";
+		is_pipelined = true;
+	} else {
+		qDebug() << "enable pipeline checkbox unchecked.";
+		is_pipelined = false;
+	}
 }
 
 void GUI::on_step_btn_clicked()
 {
-    qDebug() << "Run step button clicked.";
-    int steps = step_values[ui->step_slider->value()];
-    emit sendRunSteps(steps);
+	qDebug() << "Run step button clicked.";
+	int steps = step_values[ui->step_slider->value()];
+	emit sendRunSteps(steps);
 }
 
 void GUI::on_save_program_state_btn_clicked()
 {
-    //TODO: save program state
-    qDebug() << "save program state button is clicked.";
+	// TODO: save program state
+	qDebug() << "save program state button is clicked.";
+}
+
+QString GUI::make_status(const std::function<std::string()> &func)
+{
+	return "CONSENSUS: " + QString::fromStdString(func());
 }
diff --git a/gui/gui.h b/gui/gui.h
index aaa0ede..85f965a 100644
--- a/gui/gui.h
+++ b/gui/gui.h
@@ -1,117 +1,120 @@
 #ifndef GUI_H
 #define GUI_H
 
-#include <QMainWindow>
-#include <QThread>
-#include <QFileDialog>
+#include "worker.h"
 #include <QFile>
-#include <QTextStream>
-#include <QTextEdit>
-#include <QMessageBox>
+#include <QFileDialog>
 #include <QInputDialog>
-#include "worker.h"
+#include <QMainWindow>
+#include <QMessageBox>
+#include <QTextEdit>
+#include <QTextStream>
+#include <QThread>
+#include <functional>
 
 QT_BEGIN_NAMESPACE
-namespace Ui {
+namespace Ui
+{
 class GUI;
 }
 QT_END_NAMESPACE
 
 class GUI : public QMainWindow
 {
-    Q_OBJECT
-
-public:
-    GUI(QWidget *parent = nullptr);
-    ~GUI();
-    bool is_pipelined = false;
-    std::vector<int> ways;
-
-signals:
-    void sendRefreshDram();
-    void sendRefreshCache();
-    void sendRefreshRegisters();
-    void sendRunSteps(int steps);
-    void sendLoadProgram(std::vector<signed int> program);
-
-private slots:
-    void onWorkerClockCycles(int value, int pc);
-
-    void onWorkerFetchInfo(const std::vector<int> info);
-
-    void onWorkerDecodeInfo(const std::vector<int> info);
-
-    void onWorkerExecuteInfo(const std::vector<int> info);
-
-    void onWorkerMemoryInfo(const std::vector<int> info);
-
-    void onWorkerWriteBackInfo(const std::vector<int> info);
-
-    void onWorkerShowDram(const std::vector<std::array<signed int, LINE_SIZE>> data);
-
-    void onWorkerShowCache(const std::vector<std::array<signed int, LINE_SIZE>> data);
-
-    void onWorkerShowRegisters(const std::array<int, GPR_NUM> &data);
-
-    void onWorkerFinished();
-
-    void on_upload_intructions_btn_clicked();
-
-    void on_upload_program_state_btn_clicked();
-
-    void on_enable_pipeline_checkbox_checkStateChanged(const Qt::CheckState &arg1);
-
-    void on_step_btn_clicked();
-
-    void on_save_program_state_btn_clicked();
-
-private:
-    Ui::GUI *ui;
-    QThread workerThread;
-    Worker *worker;
-    QVector<int> step_values = {1, 5, 10, 50, 250, 1000, 10000};
-    const std::map<Mnemonic, QString> mnemonicNameMap = {
-        {Mnemonic::ADD, "ADD"},
-        {Mnemonic::SUB, "SUB"},
-        {Mnemonic::MUL, "MUL"},
-        {Mnemonic::QUOT, "QUOT"},
-        {Mnemonic::SFTR, "SFTR"},
-        {Mnemonic::SFTL, "SFTL"},
-        {Mnemonic::AND, "AND"},
-        {Mnemonic::OR, "OR"},
-        {Mnemonic::NOT, "NOT"},
-        {Mnemonic::XOR, "XOR"},
-        {Mnemonic::ADDV, "ADDV"},
-        {Mnemonic::SUBV, "SUBV"},
-        {Mnemonic::MULV, "MULV"},
-        {Mnemonic::DIVV, "DIVV"},
-        {Mnemonic::CMP, "CMP"},
-        {Mnemonic::CEV, "CEV"},
-        {Mnemonic::LOAD, "LOAD"},
-        {Mnemonic::LOADV, "LOADV"},
-        {Mnemonic::ADDI, "ADDI"},
-        {Mnemonic::SUBI, "SUBI"},
-        {Mnemonic::SFTRI, "SFTRI"},
-        {Mnemonic::SFTLI, "SFTLI"},
-        {Mnemonic::ANDI, "ANDI"},
-        {Mnemonic::ORI, "ORI"},
-        {Mnemonic::XORI, "XORI"},
-        {Mnemonic::STORE, "STORE"},
-        {Mnemonic::STOREV, "STOREV"},
-        {Mnemonic::JMP, "JMP"},
-        {Mnemonic::JRL, "JRL"},
-        {Mnemonic::JAL, "JAL"},
-        {Mnemonic::BEQ, "BEQ"},
-        {Mnemonic::BGT, "BGT"},
-        {Mnemonic::BUF, "BUF"},
-        {Mnemonic::BOF, "BOF"},
-        {Mnemonic::PUSH, "PUSH"},
-        {Mnemonic::POP, "POP"},
-        {Mnemonic::NOP, "NOP"},
-    };
-    QString mnemonicToString(Mnemonic mnemonic) {
-        auto it = mnemonicNameMap.find(mnemonic);
-        return (it != mnemonicNameMap.end()) ? it->second : "Unknown";
-    }
+	Q_OBJECT
+
+  public:
+	GUI(QWidget *parent = nullptr);
+	~GUI();
+	bool is_pipelined = false;
+	std::vector<int> ways;
+
+  signals:
+	void sendRefreshDram();
+	void sendRefreshCache();
+	void sendRefreshRegisters();
+	void sendRunSteps(int steps);
+
+  private slots:
+	void onWorkerClockCycles(int value, int pc);
+
+	void onWorkerFetchInfo(const std::vector<int> info);
+
+	void onWorkerDecodeInfo(const std::vector<int> info);
+
+	void onWorkerExecuteInfo(const std::vector<int> info);
+
+	void onWorkerMemoryInfo(const std::vector<int> info);
+
+	void onWorkerWriteBackInfo(const std::vector<int> info);
+
+	void
+	onWorkerShowDram(const std::vector<std::array<signed int, LINE_SIZE>> data);
+
+	void onWorkerShowCache(
+		const std::vector<std::array<signed int, LINE_SIZE>> data);
+
+	void onWorkerShowRegisters(const std::array<int, GPR_NUM> &data);
+
+	void onWorkerFinished();
+
+	void on_upload_intructions_btn_clicked();
+
+	void on_upload_program_state_btn_clicked();
+
+	void
+	on_enable_pipeline_checkbox_checkStateChanged(const Qt::CheckState &arg1);
+
+	void on_step_btn_clicked();
+
+	void on_save_program_state_btn_clicked();
+
+  private:
+	Ui::GUI *ui;
+
+	/**
+	 * The message displayed on the status bar.
+	 */
+	QLabel *status_label;
+
+	/**
+	 * The currently loaded program.
+	 */
+	std::vector<signed int> p;
+
+	QThread workerThread;
+
+	Worker *worker;
+
+	QVector<int> step_values = {1, 5, 10, 50, 250, 1000, 10000};
+
+	const std::map<Mnemonic, QString> mnemonicNameMap = {
+		{Mnemonic::ADD, "ADD"},		  {Mnemonic::SUB, "SUB"},
+		{Mnemonic::MUL, "MUL"},		  {Mnemonic::QUOT, "QUOT"},
+		{Mnemonic::SFTR, "SFTR"},	  {Mnemonic::SFTL, "SFTL"},
+		{Mnemonic::AND, "AND"},		  {Mnemonic::OR, "OR"},
+		{Mnemonic::NOT, "NOT"},		  {Mnemonic::XOR, "XOR"},
+		{Mnemonic::ADDV, "ADDV"},	  {Mnemonic::SUBV, "SUBV"},
+		{Mnemonic::MULV, "MULV"},	  {Mnemonic::DIVV, "DIVV"},
+		{Mnemonic::CMP, "CMP"},		  {Mnemonic::CEV, "CEV"},
+		{Mnemonic::LOAD, "LOAD"},	  {Mnemonic::LOADV, "LOADV"},
+		{Mnemonic::ADDI, "ADDI"},	  {Mnemonic::SUBI, "SUBI"},
+		{Mnemonic::SFTRI, "SFTRI"},	  {Mnemonic::SFTLI, "SFTLI"},
+		{Mnemonic::ANDI, "ANDI"},	  {Mnemonic::ORI, "ORI"},
+		{Mnemonic::XORI, "XORI"},	  {Mnemonic::STORE, "STORE"},
+		{Mnemonic::STOREV, "STOREV"}, {Mnemonic::JMP, "JMP"},
+		{Mnemonic::JRL, "JRL"},		  {Mnemonic::JAL, "JAL"},
+		{Mnemonic::BEQ, "BEQ"},		  {Mnemonic::BGT, "BGT"},
+		{Mnemonic::BUF, "BUF"},		  {Mnemonic::BOF, "BOF"},
+		{Mnemonic::PUSH, "PUSH"},	  {Mnemonic::POP, "POP"},
+		{Mnemonic::NOP, "NOP"},
+	};
+	QString mnemonicToString(Mnemonic mnemonic)
+	{
+		auto it = mnemonicNameMap.find(mnemonic);
+		return (it != mnemonicNameMap.end()) ? it->second : "Unknown";
+	}
+
+	QString make_status(const std::function<std::string()> &func);
 };
 #endif // GUI_H