test_sdk/gui/orbit/gtl_gui_orbit_widget.cpp

#include "gtl_gui_orbit_widget.h"
#include "gtl_gui_chart_widget.h"
#include "gui/ui_gtl_gui_orbit_widget.h"
#include <QMessageBox>

namespace gtl {
    namespace gui {
        namespace orbit {

            widget::widget(QWidget *parent, gtl::data_model* model)
                : QWidget(parent),
                ui(new Ui::orbit_widget)
            {
                ui->setupUi(this);

                _selection_data_model = new gtl::selection_data_model(this);
                _selection_data_model->setSourceModel(model);

                ui->signals_->setModel(_selection_data_model);
                ui->signals_->expandAll();

                ::chart::axis_horz* axis_x = new ::chart::axis_horz();
                ::chart::axis_vert* axis_y = new ::chart::axis_vert(::chart::axis_vert::down_to_up, false);
                _series = new series(parent, axis_x, axis_y);
                _chart = new chart(this, axis_x, axis_y);
                _chart->add(_series);
                ui->splitter->insertWidget(0, _chart);

                connect(ui->sig_x, &QComboBox::currentIndexChanged, [=]{
                    std::vector<analog_data*> ads;
                    _selection_data_model->get_selections(std::back_insert_iterator<std::vector<analog_data*>>(ads));
                    int idx = ui->sig_x->currentIndex();
                    if(idx >= 0 && idx < ads.size())
                        _series->set_x(ads.at(idx));
                    else
                        _series->set_x(nullptr);
                });
                ui->sig_x->setModel(_selection_data_model->selection());

                connect(ui->sig_y, &QComboBox::currentIndexChanged, [=]{
                    std::vector<analog_data*> ads;
                    _selection_data_model->get_selections(std::back_insert_iterator<std::vector<analog_data*>>(ads));
                    int idx = ui->sig_y->currentIndex();
                    if(idx >= 0 && idx < ads.size())
                        _series->set_y(ads.at(idx));
                    else
                        _series->set_y(nullptr);
                });
                ui->sig_y->setModel(_selection_data_model->selection());

                ui->time->setMinimum(0);
                ui->time->setMaximum(10000);
                ui->time->setSingleStep(0.1);
                ui->time->setValue(_series->time());
                connect(ui->time, &QDoubleSpinBox::valueChanged, _series, &series::set_time);
                connect(_series, &series::time_changed, this, &widget::update_parameters);

                ui->start->setMinimum(0);
                ui->start->setMaximum(10000);
                ui->start->setSingleStep(0.1);
                ui->start->setValue(_series->start());
                connect(ui->start, &QDoubleSpinBox::valueChanged, _series, &series::set_start);
                connect(_series, &series::start_changed, this, &widget::update_parameters);

                ui->stop->setMinimum(0);
                ui->stop->setMaximum(10000);
                ui->stop->setSingleStep(0.1);
                ui->stop->setValue(_series->stop());
                connect(ui->stop, &QDoubleSpinBox::valueChanged, _series, &series::set_stop);
                connect(_series, &series::stop_changed, this, &widget::update_parameters);

                ui->turns->setMinimum(0);
                ui->turns->setMaximum(10000);
                ui->turns->setSingleStep(0.1);
                ui->turns->setValue(_series->turns());
                connect(ui->turns, &QDoubleSpinBox::valueChanged, _series, &series::set_turns);
                connect(_series, &series::turns_changed, this, &widget::update_parameters);

                connect(_series, &series::freq_changed, [=]{
                    ui->freq->setText(QString::number(_series->freq()));
                });


            }

            widget::~widget()
            {
                delete _chart;
                delete ui;
            }

            void widget::save(QDomElement &root_element)
            {
                QDomElement selection_element = root_element.ownerDocument().createElement("selection");
                root_element.appendChild(selection_element);
                _selection_data_model->save(selection_element);

                QDomElement options_element = root_element.ownerDocument().createElement("options");
                root_element.appendChild(options_element);
                _series->save(options_element);

                QDomElement splitter_element = root_element.ownerDocument().createElement("splitter");
                root_element.appendChild(splitter_element);
                splitter_element.setAttribute("state", QString(ui->splitter->saveState().toBase64()));
            }

            void widget::load(const QDomElement &root_element)
            {
                QDomElement options_element = root_element.firstChildElement("options");
                _series->load(options_element);

                update_parameters();

                QDomElement selection_element = root_element.firstChildElement("selection");
                _selection_data_model->load(selection_element);



                QDomElement splitter_element = root_element.firstChildElement("splitter");
                ui->splitter->restoreState(QByteArray::fromBase64(splitter_element.attribute("state", "").toUtf8()));
            }

            void widget::update_parameters()
            {
                blockSignals(true);
                _series->blockSignals(true);
                ui->time->blockSignals(true);
                ui->start->blockSignals(true);
                ui->stop->blockSignals(true);
                ui->turns->blockSignals(true);

                qreal value;

                value = _series->time();
                if(value != ui->time->value())
                    ui->time->setValue(value);

                value = _series->start();
                if(value != ui->start->value())
                    ui->start->setValue(value);

                value = _series->stop();
                if(value != ui->stop->value())
                    ui->stop->setValue(value);

                value = _series->turns();
                if(value != ui->turns->value())
                    ui->turns->setValue(value);

                blockSignals(false);
                _series->blockSignals(false);
                ui->time->blockSignals(false);
                ui->start->blockSignals(false);
                ui->stop->blockSignals(false);
                ui->turns->blockSignals(false);
            }

        }
    } // namespace gui
} // namespace gtl