test_sdk/test_gtl/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include "core/gtl_logger.h"

#include "gui/osc/gtl_gui_osc_widget.h"

#include "gui/gtl_gui_options_dialog.h"
#include "gui/gtl_gui_scr_options_widget.h"


MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
#ifdef QT_DEBUG
    , _hw(new gtl::hw::hw("../.output/.hwplugins/debug", this))
#else
    , _hw(new gtl::hw::hw("../.output/.hwplugins/release", this))
#endif
{
    ui->setupUi(this);

    gtl::logger::init("./", 10, gtl::logger::mb);

    _model = new gtl::data_model(this);
    _selection_data_model = new gtl::selection_data_model(/*_model*/this);
    _selection_data_model->setSourceModel(_model);

    ui->tree_hw->setModel(_selection_data_model);


//    _device = _hw->create_device("ni", this);
//    _device = new gtl::hw::generator(this);

//    _model->add_device(_device->gtl_device());


//    _device->start("Dev1", 51200);

    gtl::gui::osc::chart* chart = new gtl::gui::osc::chart(this);
    gtl::gui::chart_widget *widget = new gtl::gui::chart_widget(chart, this);

    ui->cb_axis_y_mode->setChecked(chart->is_axis_y_multi());
    connect(ui->cb_axis_y_mode, &QCheckBox::clicked, chart, &gtl::gui::osc::chart::set_axis_y_mode);

    ui->num_time->setValue(chart->time());
    connect(ui->num_time, &QDoubleSpinBox::valueChanged, chart, &gtl::gui::osc::chart::set_time);

    ui->btn_run->setChecked(chart->is_updating());
    connect(ui->btn_run, &QPushButton::clicked, chart, &gtl::gui::chart::set_updating);

    connect(_selection_data_model, &gtl::selection_data_model::selected, chart, &gtl::gui::chart::add_ad);
    connect(_selection_data_model, &gtl::selection_data_model::deselected, chart, &gtl::gui::chart::remove_ad);

    connect(_selection_data_model, &gtl::selection_data_model::selected, &_engine, &gtl::scr::engine::add_ad);
    connect(_selection_data_model, &gtl::selection_data_model::deselected, &_engine, &gtl::scr::engine::remove_ad);

    //chart->add_ai(_device->ai(3));

//    setCentralWidget(chart);

    ui->splitter->insertWidget(0, widget);

    _scr_table = new gtl::gui::scr_table(_model, this);
    ui->frame->layout()->addWidget(_scr_table);

    ui->tabWidget->addTab(new gtl::gui::osc::widget(this, _model), "osc");

    _spec = new gtl::gui::spec_widget(this, gtl::math::spec::ausp, _model);
    ui->tabWidget->addTab(_spec, "spec");

    _apfc = new gtl::gui::apfc_widget(this, _model);
    ui->tabWidget->addTab(_apfc, "apfc");

    _cross_spec = new gtl::gui::cross_spec_widget(this, _model);
    ui->tabWidget->addTab(_cross_spec, "cross_spec");

	_octv = new gtl::gui::octv_widget(this, _model);
    ui->tabWidget->addTab(_octv, "octave");

    _orbit = new gtl::gui::orbit::widget(this, _model);
    ui->tabWidget->addTab(_orbit, "orbit");

    _diagnostic_engine = new gtl::scr::engine_diagnostic(this);
    _diagnostic = new gtl::gui::scr_widget(_diagnostic_engine, _model, this);
    

    ui->tabWidget->addTab(_diagnostic, "diagnostic");
    connect(_diagnostic, &gtl::gui::scr_widget::init_editor_menu, this, &MainWindow::init_scr_editor_menu);

    show_scr_specs_action = new QAction("Show specs");
    _scr_specs_dialog = new scr_specs_dialog(_diagnostic_engine, this);
    connect(show_scr_specs_action, &QAction::triggered, _scr_specs_dialog, &QWidget::show);

    evaluate_scr_action = new QAction("Evaluate");
    connect(evaluate_scr_action, &QAction::triggered, _diagnostic, &gtl::gui::scr_widget::evaluate);

    _get_engine_state_action = new QAction("Get state");
    connect(_get_engine_state_action, &QAction::triggered, this, &MainWindow::copy_engine_state_to_clipboard);

    _get_engine_results_action = new QAction("Get results");
    connect(_get_engine_results_action, &QAction::triggered, this, &MainWindow::copy_engine_results_to_clipboard);

    _set_engine_options_action = new QAction("Set options");
    connect(_set_engine_options_action, &QAction::triggered, this, &MainWindow::copy_engine_options_from_clipboard);

    _config_widget = new gtl::gui::config::widget(
                _model,
#ifdef QT_DEBUG
                "../.output/.hwplugins/debug"
#else
                "../.output/.hwplugins/release"
#endif
                , this
                );
    ui->tabWidget->addTab(_config_widget , "config");

    _log_viewer = new gtl::gui::log_viewer(this);
    ui->tabWidget->addTab(_log_viewer, "log");

    _recorder = new gtl::gui::recorder_widget(_model, this);
    ui->tabWidget->addTab(_recorder, "recorder");

    _qml = new gtl::gui::scr_qml_widget(_model, this);
    ui->tabWidget->addTab(_qml, "qml");

    QCoreApplication::setOrganizationName("GTLab");
    QCoreApplication::setOrganizationDomain("gtlab.pro");
    QCoreApplication::setApplicationName("test_gtl");

    gtl::gui::options_dialog* options = new gtl::gui::options_dialog(this);
    options->add_options_widget("scripts", new gtl::gui::scr_options_widget(this));

    connect(ui->actionOptions, &QAction::triggered, [=](){options->exec();});

    restore();

    gtl::logger::info("test_gtl", "start");
}

MainWindow::~MainWindow()
{
    save();

    delete ui;
}

void MainWindow::save()
{
    QDomDocument doc;
    QDomElement root = doc.createElement("test_gtl");
    doc.appendChild(root);

    root.setAttribute("geometry", saveGeometry().toBase64());
    root.setAttribute("state", saveState().toBase64());


    QDomElement config_element = doc.createElement("config");
    root.appendChild(config_element);
    _config_widget->save(config_element);

    QDomElement diagnostic_element = doc.createElement("diagnostic");
    root.appendChild(diagnostic_element);
    _diagnostic->save(diagnostic_element);

    QDomElement specs_diagnostic_element = doc.createElement("specs");
    diagnostic_element.appendChild(specs_diagnostic_element);
    _scr_specs_dialog->save(specs_diagnostic_element);

    QDomElement spec_element = doc.createElement("spec");
    root.appendChild(spec_element);
    _spec->save(spec_element);

    QDomElement orbit_element = doc.createElement("orbit");
    root.appendChild(orbit_element);
    _orbit->save(orbit_element);

    QDomElement recorder_element = doc.createElement("recorder");
    root.appendChild(recorder_element);
    _recorder->save(recorder_element);

    QDomElement qml_element = doc.createElement("qml");
    root.appendChild(qml_element);
    _qml->save(qml_element);

    QFile file_xml("workspace.gtl");
    if (file_xml.open(QIODevice::WriteOnly))
    {
        QTextStream stream(&file_xml);
//        stream.setCodec(QTextCodec::codecForName("Windows-1251"));
        doc.save(stream, 0, QDomNode::EncodingFromTextStream);
        file_xml.close();
    }
}

void MainWindow::restore()
{
    QFile file_xml("workspace.gtl");
    if (file_xml.open(QIODevice::ReadOnly))
    {
        QDomDocument doc;
        if (doc.setContent(&file_xml))
        {
            QDomElement root = doc.documentElement().toElement();

            QDomElement config_element = root.firstChildElement("config");
            _config_widget->load(config_element);

            QDomElement diagnostic_element = root.firstChildElement("diagnostic");
            _diagnostic->load(diagnostic_element);

            QDomElement specs_diagnostic_element = diagnostic_element.firstChildElement("specs");
            _scr_specs_dialog->load(specs_diagnostic_element);

            QDomElement spec_element = root.firstChildElement("spec");
            _spec->load(spec_element);

            QDomElement orbit_element = root.firstChildElement("orbit");
            _orbit->load(orbit_element);

            QDomElement recorder_element = root.firstChildElement("recorder");
            _recorder->load(recorder_element);

            _qml->load(root.firstChildElement("qml"));

            QDomElement tools_element = root.firstChildElement("tools");

            restoreGeometry(QByteArray::fromBase64(root.attribute("geometry", "").toUtf8()));
            restoreState(QByteArray::fromBase64(root.attribute("state", "").toUtf8()));
        }

    }
}

void MainWindow::init_scr_editor_menu(QMenu *menu)
{
    menu->addSeparator();
    menu->addAction(show_scr_specs_action);
    menu->addAction(evaluate_scr_action);
    menu->addSeparator();
    menu->addAction(_set_engine_options_action);
    menu->addAction(_get_engine_state_action);
    menu->addAction(_get_engine_results_action);
}

void MainWindow::copy_engine_state_to_clipboard()
{
    QJsonObject state_object;
    _diagnostic_engine->get_state(state_object);
    QJsonDocument state(state_object);
    QApplication::clipboard()->setText(QString(state.toJson()));
}

void MainWindow::copy_engine_options_from_clipboard()
{
    QJsonDocument options = QJsonDocument::fromJson(QApplication::clipboard()->text().toUtf8());
    _diagnostic_engine->set_options(options.object());
}

void MainWindow::copy_engine_results_to_clipboard()
{
    QJsonObject results_object;
    _diagnostic_engine->get_results(results_object);
    QJsonDocument state(results_object);
    QApplication::clipboard()->setText(QString(state.toJson()));
}