calculator.cpp - master - Shymer123/Calculator

calculator.cpp
554 строки17 KB
Shymer123
fixed bugs with the state of buttons during mathematical operations
06 мар 2025, 15:03
06 мар 2025, 15:03fa597f9
#include "calculator.h"
#include <QApplication>
#include <QFile>
#include <QJsonObject>
#include <QJsonDocument>

Calculator::Calculator(QWidget *parent)
    : QWidget(parent)
{
    building();
    setStartTheme();
    connecting();
    setup();
}

Calculator::~Calculator() {}

void Calculator::building()
{
    QFont fontButton("Times", 15);
    QFont fontLabel("Times", 20);

    gridlayout = new QGridLayout(this);

    Menu = new QPushButton("≡");
    Menu->setFocusPolicy(Qt::NoFocus);
    Menu->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    Menu->setFont(fontButton);

    Menu->setFixedSize(30, 30);
    gridlayout->addWidget(Menu, 0, 0, 1, 1);

    MenuFromButton = new QMenu;
    themeMenu = new QAction(tr("Theme"));
    lightAction = new QAction(tr("Light"));
    lightAction->setData(1);
    darkAction = new QAction(tr("Dark"));
    darkAction->setData(2);
    MenuFromButton->addAction(themeMenu);

    closeAction = new QAction(tr("Close"));
    MenuFromButton->addSeparator();
    MenuFromButton->addAction(closeAction);

    QMenu* menuTheme = new QMenu;
    menuTheme->addAction(lightAction);
    menuTheme->addAction(darkAction);
    themeMenu->setMenu(menuTheme);

    Menu->setMenu(MenuFromButton);

    resultLabel = new QLabel("0");
    resultLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    resultLabel->setFont(fontLabel);
    resultLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
    gridlayout->addWidget(resultLabel, 1, 0, 1, 4);

    percent = new QPushButton("%");
    percent->setFocusPolicy(Qt::NoFocus);
    percent->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    percent->setFont(fontButton);
    gridlayout->addWidget(percent, 2, 0);

    plus_minus = new QPushButton("+/-");
    plus_minus->setFocusPolicy(Qt::NoFocus);
    plus_minus->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    plus_minus->setFont(fontButton);
    gridlayout->addWidget(plus_minus, 2, 1);

    Button_C = new QPushButton("C");
    Button_C->setFocusPolicy(Qt::NoFocus);
    Button_C->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    Button_C->setFont(fontButton);
    gridlayout->addWidget(Button_C, 2, 2);

    Button_DeleteLastNumber = new QPushButton("⌫");
    Button_DeleteLastNumber->setFocusPolicy(Qt::NoFocus);
    Button_DeleteLastNumber->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    Button_DeleteLastNumber->setFont(fontButton);
    gridlayout->addWidget(Button_DeleteLastNumber, 2, 3);

    oneDivisionX = new QPushButton("1/x");
    oneDivisionX->setFocusPolicy(Qt::NoFocus);
    oneDivisionX->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    oneDivisionX->setFont(fontButton);
    gridlayout->addWidget(oneDivisionX, 3, 0);

    square_degree = new QPushButton("x²");
    square_degree->setFocusPolicy(Qt::NoFocus);
    square_degree->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    square_degree->setFont(fontButton);
    gridlayout->addWidget(square_degree, 3, 1);

    square_root = new QPushButton("√x");
    square_root->setFocusPolicy(Qt::NoFocus);
    square_root->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    square_root->setFont(fontButton);
    gridlayout->addWidget(square_root, 3, 2);

    division = new QPushButton("÷");
    division->setFocusPolicy(Qt::NoFocus);
    division->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    division->setFont(fontButton);
    gridlayout->addWidget(division, 3, 3);

    number_7 = new QPushButton("7");
    number_7->setFocusPolicy(Qt::NoFocus);
    number_7->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_7->setFont(fontButton);
    gridlayout->addWidget(number_7, 4, 0);

    number_8 = new QPushButton("8");
    number_8->setFocusPolicy(Qt::NoFocus);
    number_8->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_8->setFont(fontButton);
    gridlayout->addWidget(number_8, 4, 1);

    number_9 = new QPushButton("9", this);
    number_9->setFocusPolicy(Qt::NoFocus);
    number_9->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_9->setFont(fontButton);
    gridlayout->addWidget(number_9, 4, 2);


    multiplication = new QPushButton("×");
    multiplication->setFocusPolicy(Qt::NoFocus);
    multiplication->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    multiplication->setFont(fontButton);
    gridlayout->addWidget(multiplication, 4, 3);

    number_4 = new QPushButton("4");
    number_4->setFocusPolicy(Qt::NoFocus);
    number_4->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_4->setFont(fontButton);
    gridlayout->addWidget(number_4, 5, 0);

    number_5 = new QPushButton("5");
    number_5->setFocusPolicy(Qt::NoFocus);
    number_5->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_5->setFont(fontButton);
    gridlayout->addWidget(number_5, 5, 1);

    number_6 = new QPushButton("6");
    number_6->setFocusPolicy(Qt::NoFocus);
    number_6->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_6->setFont(fontButton);
    gridlayout->addWidget(number_6, 5, 2);

    minus = new QPushButton("-");
    minus->setFocusPolicy(Qt::NoFocus);
    minus->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    minus->setFont(fontButton);
    gridlayout->addWidget(minus, 5, 3);

    number_1 = new QPushButton("1");
    number_1->setFocusPolicy(Qt::NoFocus);
    number_1->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_1->setFont(fontButton);
    gridlayout->addWidget(number_1, 6, 0);

    number_2 = new QPushButton("2");
    number_2->setFocusPolicy(Qt::NoFocus);
    number_2->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_2->setFont(fontButton);
    gridlayout->addWidget(number_2, 6, 1);

    number_3 = new QPushButton("3");
    number_3->setFocusPolicy(Qt::NoFocus);
    number_3->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_3->setFont(fontButton);
    gridlayout->addWidget(number_3, 6, 2);

    plus = new QPushButton("+");
    plus->setFocusPolicy(Qt::NoFocus);
    plus->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    plus->setFont(fontButton);
    gridlayout->addWidget(plus, 6, 3);

    number_0 = new QPushButton("0");
    number_0->setFocusPolicy(Qt::NoFocus);
    number_0->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    number_0->setFont(fontButton);
    gridlayout->addWidget(number_0, 7, 0, 1, 2);

    Button_Point = new QPushButton(".");
    Button_Point->setFocusPolicy(Qt::NoFocus);
    Button_Point->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    Button_Point->setFont(fontButton);
    gridlayout->addWidget(Button_Point, 7, 2);

    Button_Equal = new QPushButton("=");
    Button_Equal->setFocusPolicy(Qt::NoFocus);
    Button_Equal->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    Button_Equal->setFont(fontButton);
    Button_Equal->setStyleSheet("QPushButton { background-color: #023e8a; }");
    gridlayout->addWidget(Button_Equal, 7, 3);

}

void Calculator::setup()
{
    plus->setCheckable(true);
    minus->setCheckable(true);
    multiplication->setCheckable(true);
    division->setCheckable(true);
}

void Calculator::connecting()
{
    connect(number_0, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_1, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_2, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_3, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_4, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_5, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_6, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_7, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_8, &QPushButton::clicked, this, &Calculator::connectNumbers);
    connect(number_9, &QPushButton::clicked, this, &Calculator::connectNumbers);

    connect(plus, &QPushButton::clicked, this, &Calculator::connectMathOperations);
    connect(minus, &QPushButton::clicked, this, &Calculator::connectMathOperations);
    connect(multiplication, &QPushButton::clicked, this, &Calculator::connectMathOperations);
    connect(division, &QPushButton::clicked, this, &Calculator::connectMathOperations);

    connect(Button_Equal, &QPushButton::clicked, this, &Calculator::calculateResult);

    connect(Button_C, &QPushButton::clicked, this, [&]()
            {
                resultLabel->setText("0");
                plus->setChecked(false);
                minus->setChecked(false);
                multiplication->setChecked(false);
                division->setChecked(false);

                setEnabledButtons(true);
            });

    connect(percent, &QPushButton::clicked, this, &Calculator::connectAdditionalOperations);
    connect(plus_minus, &QPushButton::clicked, this, &Calculator::connectAdditionalOperations);
    connect(oneDivisionX, &QPushButton::clicked, this, &Calculator::connectAdditionalOperations);
    connect(square_degree, &QPushButton::clicked, this, &Calculator::connectAdditionalOperations);
    connect(square_root, &QPushButton::clicked, this, &Calculator::connectAdditionalOperations);

    connect(Button_DeleteLastNumber, &QPushButton::clicked, this, [&]()
            {
                QString number = resultLabel->text();
                if(number.size() == 1)
                {
                    resultLabel->setText("0");
                }
                else
                {
                    number.chop(1);
                    resultLabel->setText(number);
                }
            });

    connect(Button_Point, &QPushButton::clicked, this, [&]()
            {
                if(!resultLabel->text().contains('.'))
                {
                    resultLabel->setText(resultLabel->text() + ".");
                }

            });

    connect(lightAction, &QAction::triggered, this, &Calculator::connectMenuActions);
    connect(darkAction, &QAction::triggered, this, &Calculator::connectMenuActions);
    connect(closeAction, &QAction::triggered, this, &QApplication::quit);
}

void Calculator::calculateResult()
{
    double numSecond;
    double resultNumber;
    QString resultText;
    numSecond = resultLabel->text().toDouble();

    if(plus->isChecked())
    {
        resultNumber = numFirst + numSecond;
        resultText = QString::number(resultNumber, 'g', 15);
        resultLabel->setText(resultText);
        plus->setChecked(false);
    }
    else if(minus->isChecked())
    {
        resultNumber = numFirst - numSecond;
        resultText = QString::number(resultNumber, 'g', 15);
        resultLabel->setText(resultText);
        minus->setChecked(false);
    }
    else if(multiplication->isChecked())
    {
        resultNumber = numFirst * numSecond;
        resultText = QString::number(resultNumber, 'g', 15);
        resultLabel->setText(resultText);
        multiplication->setChecked(false);
    }
    else if(division->isChecked())
    {
        if(numSecond != 0)
        {
            resultNumber = numFirst / numSecond;
            resultText = QString::number(resultNumber, 'g', 15);
            resultLabel->setText(resultText);
            division->setChecked(false);
        }
        else
        {
            resultLabel->setText(tr("division by zero is not possible"));
            division->setChecked(false);
        }
    }

    setEnabledButtons(true);
}

void Calculator::setEnabledButtons(bool enabled)
{
    plus_minus->setEnabled(enabled);
    percent->setEnabled(enabled);
    square_root->setEnabled(enabled);
    square_degree->setEnabled(enabled);
    oneDivisionX->setEnabled(enabled);
    plus->setEnabled(enabled);
    minus->setEnabled(enabled);
    multiplication->setEnabled(enabled);
    division->setEnabled(enabled);
}

void Calculator::keyPressEvent(QKeyEvent *event)
{
    QString oldText = resultLabel->text();
    int key = event->key();

    if(key >= Qt::Key_0 && key <= Qt::Key_9)
    {
        QString str = static_cast<QString>(QChar(key));
        if (oldText.contains('.'))
        {
            QStringList parts = oldText.split('.');
            if (parts.size() > 1 && parts[1].size() >= 15) {
                return;
            }
        }

        if(oldText == "0")
        {
            oldText.clear();
        }
        resultLabel->setText(oldText + str);
    }
    else if(key == Qt::Key_Period)
    {
        if (!oldText.contains('.')) {
            resultLabel->setText(oldText + ".");
        }
    }
    else if(key == Qt::Key_Enter || key == Qt::Key_Return)
    {
        calculateResult();
    }
    else if(key == Qt::Key_Escape || key == Qt::Key_C)
    {
        resultLabel->setText("0");
    }
    else if(key == Qt::Key_Backspace)
    {
        if(oldText.size() == 1)
        {
            resultLabel->setText("0");
        }
        else
        {
            oldText.chop(1);
            resultLabel->setText(oldText);
        }
    }

    QWidget::keyPressEvent(event);
}

void Calculator::connectNumbers()
{
    QPushButton* button = qobject_cast<QPushButton*>(sender());
    QString numberLabel = resultLabel->text();

    if (numberLabel.contains('.'))
    {
        QStringList parts = numberLabel.split('.');
        if (parts.size() > 1 && parts[1].size() >= 15) {
            return;
        }
    }

    if (numberLabel == "0" || numberLabel == "division by zero is not possible") {
        numberLabel.clear();
    }
    numberLabel += button->text();

    resultLabel->setText(numberLabel);
}

void Calculator::connectMathOperations()
{
    QPushButton* button = qobject_cast<QPushButton*>(sender());
    numFirst = resultLabel->text().toDouble();
    resultLabel->setText("");
    button->setChecked(true);

    setEnabledButtons(false);
}

void Calculator::connectAdditionalOperations()
{
    QPushButton* button = qobject_cast<QPushButton*>(sender());
    QString textOnButton = button->text();
    QString numberOnLabel = resultLabel->text();
    double result = numberOnLabel.toDouble();

    if(textOnButton == "%")
    {
        result *= 0.01;
        resultLabel->setText(QString::number(result, 'g', 15));
    }
    else if(textOnButton == "+/-")
    {
        result *= -1;
        resultLabel->setText(QString::number(result, 'g', 15));
    }
    else if(textOnButton == "1/x")
    {
        if(result != 0)
        {
            result = 1 / result;
            resultLabel->setText(QString::number(result, 'g', 15));
        }
        else
        {
            resultLabel->setText(tr("division by zero is not possible"));
        }
    }
    else if(textOnButton == "x²")
    {
        result = std::pow(result, 2);
        resultLabel->setText(QString::number(result, 'g', 15));
    }
    else if(textOnButton == "√x")
    {
        result = std::sqrt(result);
        resultLabel->setText(QString::number(result, 'g', 15));
    }
}

void Calculator::setStartTheme()
{
    QFile file("settings.json");
    if(file.open(QIODevice::ReadOnly))
    {
        QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
        file.close();

        if (doc.isObject()) {
            QJsonObject settings = doc.object();
            if (settings.contains("themes")) {
                int themeId = settings["themes"].toInt();
                if (themeId == 1) {
                    LightTheme();
                }
                else if (themeId == 2) {
                    DarkTheme();
                }
            }
        }
    }
}

void Calculator::connectMenuActions()
{
    QAction* action = qobject_cast<QAction*>(sender());

    if(action->data() == 1)
    {
        LightTheme();
        saveThemeToSettings(1);
    }
    else if(action->data() == 2)
    {
        DarkTheme();
        saveThemeToSettings(2);
    }
}

void Calculator::saveThemeToSettings(int themeID)
{
    QFile file("settings.json");
    if(file.open(QIODevice::ReadWrite))
    {
        QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
        QJsonObject settings = doc.object();

        settings["themes"] = themeID;

        file.resize(0);
        QTextStream stream(&file);
        stream << QJsonDocument(settings).toJson();

        file.close();
    }
}

void Calculator::LightTheme()
{
    QPalette lightPalette;

    lightPalette.setColor(QPalette::Window, Qt::white);
    lightPalette.setColor(QPalette::Button, Qt::white);
    lightPalette.setColor(QPalette::ButtonText, Qt::black);

    qApp->setPalette(lightPalette);

    QString style = loadStyleSheet(":/Themes/lightTheme.css");
    qApp->setStyleSheet(style);
}

void Calculator::DarkTheme()
{
    QPalette darkPalette;

    darkPalette.setColor(QPalette::Window, QColor(53, 53, 53));
    darkPalette.setColor(QPalette::Button, QColor(53, 53, 53));
    darkPalette.setColor(QPalette::ButtonText, Qt::white);

    qApp->setPalette(darkPalette);

    QString style = loadStyleSheet(":/Themes/darkTheme.css");
    qApp->setStyleSheet(style);
}


QString Calculator::loadStyleSheet(const QString& path)
{
    QFile file(path);
    if(file.open(QFile::ReadOnly))
    {
        QTextStream stream(&file);

        QString style = stream.readAll();
        file.close();
        return style;
    }
}