mainwindow.cpp

#include "mainwindow.h"
#include "datamodel.h"
#include "degreesmodel.h"
#include "polynomial.h"
#include "ui_mainwindow.h"

#include <QDataStream>
#include <QDebug>
#include <QFile>
#include <QFileDialog>
#include <QProgressDialog>
#include <QSettings>
#include <QTextStream>
#include <QThread>
#include <QToolBar>

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow{parent}
    , ui{new Ui::MainWindow} //
{
    ui->setupUi(this);

    auto dataModel = new DataModel(ui->tvData);
    ui->tvData->setModel(dataModel);

    [this]<auto... D>(Seq<D...>) {
        (ui->cbxDegrees->addItem(QString::number(D + 1), D + 1), ...);
        QSize size{0, QFontMetrics{font()}.height() + 6};
        (ui->cbxDegrees->setItemData(D, size, Qt::SizeHintRole), ...);
        (ui->cbxDegrees->setItemData(D, Qt::AlignCenter, Qt::TextAlignmentRole), ...);
        ui->cbxDegrees->setMaxVisibleItems(sizeof...(D));
    }(MakeSeq<MaxDegree>{});

    auto degreesModel = new DegreesModel(ui->tvDegrees);
    ui->tvDegrees->setModel(degreesModel);

    { // menu File
        auto menu = menuBar()->addMenu(u"&Файл"_s);

        menu->addAction(QIcon::fromTheme(u"document-open"_s),
            u"Загрузить данные..."_s,
            QKeySequence::Open,
            this, &MainWindow::loadData);

        menu->addAction(QIcon::fromTheme(u"document-save"_s),
            u"Сохранить данные"_s,
            this, &MainWindow::saveData);

        menu->addAction(QIcon::fromTheme(u"document-save-as"_s),
            u"Сохранить данные как..."_s,
            this, &MainWindow::saveDataAs);

        menu->addSeparator();

        menu->addAction(QIcon::fromTheme(u"document-open"_s),
            u"Загрузить коэффициенты..."_s,
            this, &MainWindow::loadDegrees);

        menu->addAction(QIcon::fromTheme(u"document-save"_s),
            u"Сохранить коэффициенты"_s,
            QKeySequence::Save,
            this, &MainWindow::saveDegrees);

        menu->addAction(QIcon::fromTheme(u"document-save-as"_s),
            u"Сохранить коэффициенты как..."_s,
            QKeySequence{u"Ctrl+Alt+S"_s},
            this, &MainWindow::saveDegreesAs);

        menu->addSeparator();

        menu->addAction(QIcon::fromTheme(u"application-exit"_s),
            u"Выход"_s,
            QKeySequence{u"Ctrl+Q"_s},
            this, &MainWindow::close);
    }
    { // menu Справка
        auto menu = menuBar()->addMenu(u"Справка"_s);
        menu->addAction(QIcon::fromTheme(u"help-about"_s), u"О Qt"_s, [] { qApp->aboutQt(); });
    }

    { // toolbar Управление

        auto toolbar = addToolBar(u"Управление"_s);
        toolbar->setObjectName("toolbar");
        toolbar->setIconSize({22, 22});
        auto action1 = toolbar->addAction(QIcon::fromTheme(u"format-precision-less"_s),
            {},
            [this] { ui->sbxPrecision->setValue(ui->sbxPrecision->value() - 1); });
        auto action2 = toolbar->addAction(QIcon::fromTheme(u"format-precision-more"_s),
            {},
            [this] { ui->sbxPrecision->setValue(ui->sbxPrecision->value() + 1); });
        connect(ui->sbxPrecision, qOverload<int>(&QSpinBox::valueChanged),
            [this, action1, action2]() {
                action1->setEnabled(ui->sbxPrecision->value() != ui->sbxPrecision->minimum());
                action2->setEnabled(ui->sbxPrecision->value() != ui->sbxPrecision->maximum());
            });
        toolbar->addSeparator();
        toolbar->addAction(QIcon::fromTheme(u"labplot-xy-fit-curve"_s), u"Рассчитать полином "_s, [this] {
            poly.calcDegrees(ui->cbxDegrees->currentData().toInt());
        });
        toolbar->addAction(QIcon::fromTheme(u"labplot-xy-smoothing-curve"_s), u"Пересчитать данные"_s, [this, dataModel] {
            poly.calcData(dataModel->data());
        });
        toolbar->addSeparator();
        toolbar->addAction(QIcon::fromTheme(u"help-about"_s), u"Бенчмарк"_s, this, &MainWindow::bench);
    }

    connect(&poly, &Polynomial::dataChanged,
        ui->gvData, &ChartView::setData2);
    connect(&poly, &Polynomial::deltaChanged,
        ui->gvDelta, &ChartView::setDeltaData);
    connect(&poly, &Polynomial::degreesChanged,
        degreesModel, &DegreesModel::setCoeffData);
    connect(&poly, &Polynomial::dataChanged,
        dataModel, &DataModel::setNewData);

    connect(degreesModel, &DegreesModel::dataChanged_,
        &poly, &Polynomial::setDegrees);

    connect(dataModel, &DataModel::dataChanged_,
        &poly, &Polynomial::setData);
    connect(dataModel, &DataModel::dataChanged_,
        [this](const Data&) { emit ui->cbxDegrees->currentIndexChanged(0); });
    connect(dataModel, &DataModel::dataChanged_,
        ui->gvData, &ChartView::setData);

    connect(ui->cbxDegrees, &QComboBox::currentIndexChanged,
        [this] { poly.calcDegrees(ui->cbxDegrees->currentData().toInt()); });
    connect(ui->sbxPrecision, &QSpinBox::valueChanged,
        degreesModel, &DegreesModel::setPrecision);
    connect(ui->sbxPrecision, &QSpinBox::valueChanged,
        dataModel, &DataModel::setPrecision);

    loadSetings();
}

MainWindow::~MainWindow() {
    saveSetings();
    delete ui;
}

void MainWindow::saveSetings() {
    QSettings settings;
    settings.beginGroup(u"MainWindow"_s);

    settings.setValue(u"degreesFileName"_s, degreesFileName);
    settings.setValue(u"dataFileName"_s, dataFileName);

    settings.setValue(u"geometry"_s, saveGeometry());
    settings.setValue(u"state"_s, saveState());
    settings.setValue(u"cbxDegrees"_s, ui->cbxDegrees->currentIndex());
    settings.setValue(u"sbxPrecision"_s, ui->sbxPrecision->value());
    settings.setValue(u"splitter"_s, ui->splitter->saveState());
    settings.endGroup();

    // settings.beginGroup(u"Data"_s);
    ui->tvData->model<DataModel>()->save(u"polydata.bin"_s);
    // settings.endGroup();
}

void MainWindow::loadSetings() {
    QSettings settings;
    settings.beginGroup(u"MainWindow"_s);

    degreesFileName = settings.value(u"degreesFileName"_s).toString();
    dataFileName = settings.value(u"dataFileName"_s).toString();

    restoreGeometry(settings.value(u"geometry"_s).toByteArray());
    restoreState(settings.value(u"state"_s).toByteArray());
    ui->cbxDegrees->setCurrentIndex(settings.value(u"cbxDegrees"_s).toInt());
    ui->sbxPrecision->setValue(settings.value(u"sbxPrecision"_s).toInt());
    ui->splitter->restoreState(settings.value(u"splitter"_s).toByteArray());
    settings.endGroup();

    // if(QFileInfo::exists(dataFileName))
    //     ui->tvData->model<DataModel>()->load(dataFileName);
    // else {
    // settings.beginGroup(u"Data"_s);
    ui->tvData->model<DataModel>()->load(u"polydata.bin"_s);
    // settings.endGroup();
    // }
}

void MainWindow::loadData() {
    if(auto fileName{QFileDialog::getOpenFileName(this, actionName(), dataFileName, u"*.txt;;*.bin"_s)}; fileName.isEmpty())
        return;
    else
        dataFileName = fileName;
    ui->tvData->model<DataModel>()->load(dataFileName);
}

void MainWindow::saveData() {
    if(dataFileName.isEmpty())
        dataFileName = QFileDialog::getSaveFileName(this, actionName(), {}, u"*.txt;;*.bin"_s);
    ui->tvData->model<DataModel>()->save(dataFileName);
}

void MainWindow::saveDataAs() {
    dataFileName = QFileDialog::getSaveFileName(this, actionName(), dataFileName, u"*.txt;;*.bin"_s);
    ui->tvData->model<DataModel>()->save(dataFileName);
}

void MainWindow::loadDegrees() {
    if(auto fileName{QFileDialog::getOpenFileName(this, actionName(), degreesFileName, u"*.txt;;*.bin"_s)}; fileName.isEmpty())
        return;
    else
        degreesFileName = fileName;
    ui->tvData->model<DegreesModel>()->load(degreesFileName);
}

void MainWindow::saveDegrees() {
    if(degreesFileName.isEmpty())
        degreesFileName = QFileDialog::getSaveFileName(this, actionName(), {}, u"*.txt;;*.bin"_s);
    ui->tvData->model<DegreesModel>()->save(degreesFileName);
}

void MainWindow::saveDegreesAs() {
    degreesFileName = QFileDialog::getSaveFileName(this, actionName(), degreesFileName, u"*.txt;;*.bin"_s);
    ui->tvData->model<DegreesModel>()->save(degreesFileName);
}

QString MainWindow::actionName() {
    if(auto action = qobject_cast<QAction*>(sender()); action)
        return action->text();
    return {};
}

void MainWindow::bench() {
    Timer::avg.clear();
    Timer::ctr.clear();
    QProgressDialog pd;
    pd.setMaximum(99);
    Polynomial poly;
    poly.setData(ui->tvData->model<DataModel>()->data());
    Bench run(poly);
    connect(&pd, &QProgressDialog::canceled, &run, &QThread::requestInterruption);
    connect(&run, &Bench::val, &pd, &QProgressDialog::setValue);
    run.start();
    pd.exec();
    run.wait();
    class Dialog final : public QDialog {
    public:
        Dialog() {
            if(objectName().isEmpty())
                setObjectName(u"Dialog"_s);
            resize(400, 720);
            setWindowTitle(u"Бенчмарк"_s);

            auto verticalLayout = new QVBoxLayout{this};
            verticalLayout->setObjectName(u"verticalLayout"_s);
            verticalLayout->setContentsMargins(6, 6, 6, 6);

            auto tableView = new QTableView{this};
            tableView->setObjectName(u"tableView"_s);
            verticalLayout->addWidget(tableView);

            struct Model final : public QAbstractTableModel {
                std::vector<std::pair<std::string_view, double>> data_;

            public:
                Model() {
                    for(auto [key, val]: Timer::avg)
                        data_.emplace_back(key, val / Timer::ctr[key]);
                    r::reverse(data_);
                }
                int rowCount(const QModelIndex& = {}) const override { return data_.size(); }
                int columnCount(const QModelIndex& = {}) const override { return 1; }
                QVariant data(const QModelIndex& index, int role) const override {
                    if(role == Qt::DisplayRole)
                        return data_[index.row()].second;
                    else if(role == Qt::TextAlignmentRole)
                        return Qt::AlignCenter;
                    return {};
                }
                QVariant headerData(int section, Qt::Orientation orientation, int role) const override {
                    if(role == Qt::DisplayRole) {
                        if(orientation == Qt::Horizontal)
                            return u"Время, мксек."_s;
                        else
                            return QString::fromUtf8(data_[section].first);
                    }
                    return {};
                }
                Qt::ItemFlags flags(const QModelIndex& = {}) const override { return Qt::ItemIsEnabled; }
            };
            tableView->setModel(new Model);
            tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
            tableView->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
            QMetaObject::connectSlotsByName(this);
        }
    } dialog;
    dialog.exec();
}