gui.cpp

Go to the documentation of this file.

 
#include "gui.h"
#include "ui_gui.h"
 
#include <QMessageBox>
#include <QKeyEvent>
#include <QString>
#include <cmath>
 
Gui::Gui(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::Gui),
      justEvaluated(false)
{
    ui->setupUi(this);
    currentExpression.clear();
}
 
Gui::~Gui()
{
    delete ui;
}
 
void Gui::showError(mathlib::MathError err)
{
    switch (err) {
        case mathlib::DIVISION_BY_ZERO:
            QMessageBox::warning(this, "Error", "Division by zero!");
            break;
        case mathlib::NEGATIVE_FACTORIAL:
            QMessageBox::warning(this, "Error", "Factorial of negative number!");
            break;
        case mathlib::INVALID_ROOT:
            QMessageBox::warning(this, "Error", "Invalid root operation!");
            break;
        case mathlib::INVALID_ARGUMENT:
            QMessageBox::warning(this, "Error", "Invalid argument!");
            break;
        default:
            break;
    }
}
 
void Gui::updateDisplay()
{
    ui->display->setText(currentExpression.isEmpty() ? "0" : currentExpression);
}
 
bool Gui::endsWithOperator() const
{
    if (currentExpression.isEmpty()) return false;
    QChar last = currentExpression.back();
    return last == '+' || last == '-' || last == '*' ||
           last == '/' || last == '%' || last == '^';
}
 
bool Gui::hasOperator() const
{
    // Start scanning from index 1 to allow a leading negative sign
    for (int i = 1; i < currentExpression.size(); ++i) {
        QChar c = currentExpression[i];
        if (c == '+' || c == '*' || c == '/' || c == '%' || c == '^')
            return true;
        // A '-' that isn't at position 0 counts as an operator
        if (c == '-')
            return true;
    }
    return false;
}
 
void Gui::appendDigit(const QString &digit)
{
    if (justEvaluated) {
        currentExpression.clear();
        justEvaluated = false;
    }
    currentExpression += digit;
    updateDisplay();
}
 
void Gui::appendOperator(const QString &op)
{
    // After evaluation, chain onto the result
    if (justEvaluated) {
        justEvaluated = false;
    }
 
    // Don't allow an operator on an empty expression
    // (except minus, which creates a negative number)
    if (currentExpression.isEmpty()) {
        if (op == "-") {
            currentExpression += op;
            updateDisplay();
        }
        return;
    }
 
    // If expression already ends with an operator, replace it
    if (endsWithOperator()) {
        currentExpression.chop(1);
        currentExpression += op;
        updateDisplay();
        return;
    }
 
    // Only allow one binary operator per expression
    if (hasOperator()) {
        return;
    }
 
    currentExpression += op;
    updateDisplay();
}
 
// ---- Digit button handlers ----
 
void Gui::on_btn_0_clicked() { appendDigit("0"); }
void Gui::on_btn_1_clicked() { appendDigit("1"); }
void Gui::on_btn_2_clicked() { appendDigit("2"); }
void Gui::on_btn_3_clicked() { appendDigit("3"); }
void Gui::on_btn_4_clicked() { appendDigit("4"); }
void Gui::on_btn_5_clicked() { appendDigit("5"); }
void Gui::on_btn_6_clicked() { appendDigit("6"); }
void Gui::on_btn_7_clicked() { appendDigit("7"); }
void Gui::on_btn_8_clicked() { appendDigit("8"); }
void Gui::on_btn_9_clicked() { appendDigit("9"); }
 
// ---- Operator button handlers ----
 
void Gui::on_btn_plus_clicked()  { appendOperator("+"); }
void Gui::on_btn_minus_clicked() { appendOperator("-"); }
void Gui::on_btn_mul_clicked()   { appendOperator("*"); }
void Gui::on_btn_div_clicked()   { appendOperator("/"); }
void Gui::on_btn_mod_clicked()   { appendOperator("%"); }
void Gui::on_btn_pow_clicked()   { appendOperator("^"); }
 
void Gui::on_btn_dot_clicked()
{
    if (justEvaluated) {
        currentExpression.clear();
        justEvaluated = false;
    }
 
    // Find the current number segment (after the last operator)
    int lastOp = -1;
    for (int i = currentExpression.size() - 1; i >= 0; --i) {
        QChar c = currentExpression[i];
        if (c == '+' || c == '-' || c == '*' ||
            c == '/' || c == '%' || c == '^') {
            lastOp = i;
            break;
        }
    }
    QString segment = currentExpression.mid(lastOp + 1);
 
    // Only add a dot if this number segment doesn't already have one
    if (!segment.contains('.')) {
        currentExpression += ".";
        updateDisplay();
    }
}
 
void Gui::on_btn_root_clicked()
{
    if (justEvaluated) {
        currentExpression.clear();
        justEvaluated = false;
    }
 
    // √ is a prefix unary op — only valid at the beginning
    if (currentExpression.isEmpty()) {
        currentExpression = "√";
        updateDisplay();
    }
}
 
void Gui::on_btn_fac_clicked()
{
    if (justEvaluated) {
        justEvaluated = false;
    }
 
    if (currentExpression.isEmpty() || endsWithOperator())
        return;
 
    // Don't allow factorial if there's already an operator (keeps single-op rule)
    // but do allow it as the sole operation on a plain number
    if (hasOperator())
        return;
 
    // Don't allow double factorial
    if (currentExpression.endsWith("!"))
        return;
 
    currentExpression += "!";
    updateDisplay();
}
 
void Gui::on_btn_clear_clicked()
{
    currentExpression.clear();
    justEvaluated = false;
    updateDisplay();
}
 
int Gui::findOperatorPos(QChar op) const
{
    // Start at 1 to skip a possible leading negative sign
    for (int i = 1; i < currentExpression.size(); ++i) {
        if (currentExpression[i] == op)
            return i;
    }
    return -1;
}
 
void Gui::on_btn_equal_clicked()
{
    if (currentExpression.isEmpty())
        return;
 
 
    if (justEvaluated)
        return;
 
 
    if (endsWithOperator())
        return;
 
    mathlib::MathError err = mathlib::OK;
    double result = 0.0;
    bool evaluated = false;
 
 
 
 
    if (currentExpression.endsWith("!")) {
        int val = currentExpression.chopped(1).toInt();
        result = mathlib::factorial(val, err);
        evaluated = true;
    }
 
    else if (currentExpression.startsWith("√")) {
        double val = currentExpression.mid(1).toDouble();
        result = mathlib::root(val, 2, err);
        evaluated = true;
    }
 
 
 
    if (!evaluated) {
        int pos = -1;
        QChar op = '\0';
 
 
        const QString ops = "+*/%^";
        for (QChar c : ops) {
            pos = findOperatorPos(c);
            if (pos != -1) { op = c; break; }
        }
 
        if (pos == -1) {
            pos = findOperatorPos('-');
            if (pos != -1) op = '-';
        }
 
        if (pos != -1) {
            double left  = currentExpression.left(pos).toDouble();
            double right = currentExpression.mid(pos + 1).toDouble();
 
            if (op == '+')      result = mathlib::add(left, right);
            else if (op == '-') result = mathlib::subtract(left, right);
            else if (op == '*') result = mathlib::multiply(left, right);
            else if (op == '/') result = mathlib::divide(left, right, err);
            else if (op == '%') result = mathlib::modulo(left, right, err);
            else if (op == '^') result = mathlib::power(left, static_cast<int>(right));
 
            evaluated = true;
        }
    }
 
    // Plain number — just keep it
    if (!evaluated) {
        result = currentExpression.toDouble();
    }
 
    if (err != mathlib::OK) {
        showError(err);
        currentExpression.clear();
        justEvaluated = false;
        updateDisplay();
        return;
    }
 
    currentExpression = QString::number(result);
    justEvaluated = true;
    updateDisplay();
}
 
void Gui::keyPressEvent(QKeyEvent *event)
{
    int key = event->key();
 
    // Digit keys 0-9
    if (key >= Qt::Key_0 && key <= Qt::Key_9) {
        appendDigit(QString::number(key - Qt::Key_0));
        return;
    }
 
    switch (key) {
        // Basic operators
        case Qt::Key_Plus:
            appendOperator("+");
            break;
        case Qt::Key_Minus:
            appendOperator("-");
            break;
        case Qt::Key_Asterisk:
            appendOperator("*");
            break;
        case Qt::Key_Slash:
            appendOperator("/");
            break;
        case Qt::Key_Percent:
            appendOperator("%");
            break;
        case Qt::Key_AsciiCircum:
            appendOperator("^");
            break;
        case Qt::Key_Exclam:
            on_btn_fac_clicked();
            break;
 
        // Decimal point
        case Qt::Key_Period:
        case Qt::Key_Comma:
            on_btn_dot_clicked();
            break;
 
        // Evaluate
        case Qt::Key_Return:
        case Qt::Key_Enter:
        case Qt::Key_Equal:
            on_btn_equal_clicked();
            break;
 
        // Backspace — delete last character
        case Qt::Key_Backspace:
            if (justEvaluated) {
                currentExpression.clear();
                justEvaluated = false;
            } else if (!currentExpression.isEmpty()) {
                currentExpression.chop(1);
            }
            updateDisplay();
            break;
 
        // Clear
        case Qt::Key_Escape:
        case Qt::Key_Delete:
        case Qt::Key_C:
            on_btn_clear_clicked();
            break;
 
        default:
            QMainWindow::keyPressEvent(event);
            break;
    }
}