276 lines
11 KiB
C++
276 lines
11 KiB
C++
#include "gtl_gui_spec_widget.h"
|
|
#include "gui/ui_gtl_gui_spec_widget.h"
|
|
#include "gui/gtl_gui_chart_widget.h"
|
|
#include "gui/gtl_gui_spec_meas_model.h"
|
|
#include "gui/gtl_gui_spec_meas_delegate.h"
|
|
|
|
#include "gui/gtl_gui_chart_single_markers_view.h"
|
|
#include "gui/spec/gtl_gui_spec_band_markers_view.h"
|
|
#include "gui/spec/gtl_gui_spec_harm_markers_view.h"
|
|
|
|
namespace gtl
|
|
{
|
|
namespace gui
|
|
{
|
|
spec_widget::spec_widget(QWidget *parent, gtl::math::spec::types type, gtl::data_model* model) :
|
|
QWidget(parent),
|
|
ui(new Ui::spec_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();
|
|
|
|
// ui->signals_->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
// connect(ui->signals_, &QWidget::customContextMenuRequested, this, &spec_widget::menu_request);
|
|
// _spectrogramm_action = new QAction(tr("spectrogramm"), this);
|
|
// connect(_spectrogramm_action, &QAction::triggered, this, &spec_widget::spectrogramm);
|
|
|
|
_chart = new gtl::gui::spec_chart(type, this);
|
|
gtl::gui::chart_widget *chart_widget = new gtl::gui::chart_widget(_chart, this);
|
|
ui->splitter->insertWidget(0, chart_widget);
|
|
|
|
connect(_selection_data_model, >l::selection_data_model::selected, _chart, >l::gui::chart::add_ad);
|
|
connect(_selection_data_model, >l::selection_data_model::deselected, _chart, >l::gui::chart::remove_ad);
|
|
|
|
ui->frequency->disconnect();
|
|
ui->frequency->setMaximum(100000);
|
|
ui->frequency->setValue(_chart->frequency());
|
|
connect(ui->frequency, &QDoubleSpinBox::valueChanged, _chart, >l::gui::spec_chart::set_frequency);
|
|
|
|
ui->resolution->disconnect();
|
|
ui->resolution->setMaximum(100000);
|
|
ui->resolution->setValue(_chart->resolution());
|
|
connect(ui->resolution, &QDoubleSpinBox::valueChanged, _chart, >l::gui::spec_chart::set_resolution);
|
|
|
|
ui->lines->disconnect();
|
|
ui->lines->setMaximum(100000);
|
|
ui->lines->setValue(_chart->lines());
|
|
connect(ui->lines, &QDoubleSpinBox::valueChanged, _chart, >l::gui::spec_chart::set_lines);
|
|
|
|
QMetaEnum meta_enum = QMetaEnum::fromType<gtl::math::spec::windows>();
|
|
ui->window->disconnect();
|
|
ui->window->clear();
|
|
for(int i = 0; i < meta_enum.keyCount(); i++)
|
|
{
|
|
ui->window->addItem(meta_enum.valueToKey(i));
|
|
}
|
|
// ui->window-> addItems(_chart->windows_list());
|
|
ui->window->setCurrentIndex(_chart->window());
|
|
connect(ui->window, &QComboBox::currentIndexChanged, _chart, >l::gui::spec_chart::set_window);
|
|
|
|
meta_enum = QMetaEnum::fromType<gtl::math::spec::types>();
|
|
ui->type->disconnect();
|
|
ui->type->clear();
|
|
for(int i = 0; i < meta_enum.keyCount() - 1; i++)
|
|
ui->type->addItem(meta_enum.valueToKey(i));
|
|
ui->type->setCurrentIndex(_chart->type());
|
|
connect(ui->type, &QComboBox::currentIndexChanged, _chart, >l::gui::spec_chart::set_type);
|
|
|
|
|
|
ui->average->disconnect();
|
|
ui->average->setMaximum(100);
|
|
ui->average->setValue(_chart->average());
|
|
connect(ui->average, &QDoubleSpinBox::valueChanged, _chart, >l::gui::spec_chart::set_average);
|
|
|
|
ui->overlap->disconnect();
|
|
ui->overlap->setMaximum(99);
|
|
ui->overlap->setValue(_chart->overlap());
|
|
connect(ui->overlap, &QDoubleSpinBox::valueChanged, _chart, >l::gui::spec_chart::set_overlap);
|
|
|
|
ui->unit->disconnect();
|
|
ui->unit->clear();
|
|
ui->unit->addItem("unit");
|
|
ui->unit->addItem("db");
|
|
// ui->unit-> addItems(_chart->units_list());
|
|
ui->unit->setCurrentIndex(_chart->unit());
|
|
connect(ui->unit, &QComboBox::currentIndexChanged, _chart, >l::gui::spec_chart::set_unit);
|
|
|
|
connect(_chart, >l::gui::spec_chart::frequency_changed, this, >l::gui::spec_widget::update_parameters);
|
|
connect(_chart, >l::gui::spec_chart::resolution_changed, this, >l::gui::spec_widget::update_parameters);
|
|
connect(_chart, >l::gui::spec_chart::lines_changed, this, >l::gui::spec_widget::update_parameters);
|
|
connect(_chart, >l::gui::spec_chart::window_changed, this, >l::gui::spec_widget::update_parameters);
|
|
|
|
ui->y_mode->setChecked(_chart->is_axis_y_multi());
|
|
connect(ui->y_mode, &QCheckBox::toggled, _chart, >l::gui::chart::set_axis_y_mode);
|
|
connect(_chart, >l::gui::chart::axis_y_mode_changed, ui->y_mode, &QCheckBox::setChecked);
|
|
|
|
ui->x_log->setVisible(false);
|
|
connect(ui->x_log, &QCheckBox::toggled, _chart, >l::gui::spec_chart::set_x_log);
|
|
|
|
gui::spec_meas_model *meas_model = new spec_meas_model(this, _selection_data_model->selection());
|
|
_chart->set_measures(meas_model);
|
|
gui::spec_meas_delegate *meas_delegate = new spec_meas_delegate(this, meas_model->channels());
|
|
_meas_widget = new gtl::gui::meas_widget(this, meas_model, meas_delegate);
|
|
ui->tab_parameters->setVisible(false);
|
|
ui->tab_parameters->addTab(_meas_widget, tr("Meas Parameters"));
|
|
connect(ui->meas_check, &QCheckBox::toggled, this, &spec_widget::toogle_meas);
|
|
connect(meas_model, &spec_meas_model::measure_changed, [=]{ _chart->set_measures(meas_model); });
|
|
|
|
// connect(parent, &QObject::destroyed, [=]{
|
|
// delete _chart;
|
|
// _chart = nullptr;
|
|
// });
|
|
|
|
ui->tab_parameters->addTab(new chart_single_markers_view(_chart->single_markers(), this), "Single markers");
|
|
ui->tab_parameters->addTab(new spec::band_markers_view(_chart->band_markers(), this), "Band markers");
|
|
ui->tab_parameters->addTab(new spec::harm_markers_view(_chart->harm_markers(), this), "Harmonic markers");
|
|
|
|
}
|
|
|
|
|
|
spec_widget::~spec_widget()
|
|
{
|
|
if(_chart) delete _chart;
|
|
if(_meas_widget) delete _meas_widget;
|
|
delete ui;
|
|
}
|
|
|
|
void spec_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);
|
|
_chart->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 spec_widget::load(const QDomElement &root_element)
|
|
{
|
|
QDomElement options_element = root_element.firstChildElement("options");
|
|
_chart->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()));
|
|
}
|
|
|
|
data_model_node *spec_widget::active_node()
|
|
{
|
|
QModelIndex index = ui->signals_->currentIndex();
|
|
|
|
if(index.isValid() && (index.model()->data(index, Qt::CheckStateRole) == Qt::Checked))
|
|
return static_cast<gtl::data_model_node*>(index.internalPointer());
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
spgr::widget *spec_widget::create_spgr(QWidget *parent)
|
|
{
|
|
return create_spgr(parent, active_node());
|
|
}
|
|
|
|
spgr::widget *spec_widget::create_spgr(QWidget *parent, data_model_node *node)
|
|
{
|
|
return _chart->create_spgr(parent, node);
|
|
}
|
|
|
|
void spec_widget::set_type(math::spec::types type)
|
|
{
|
|
_chart->set_type(type);
|
|
}
|
|
|
|
void spec_widget::update_parameters()
|
|
{
|
|
ui->type->blockSignals(true);
|
|
ui->frequency->blockSignals(true);
|
|
ui->resolution->blockSignals(true);
|
|
ui->lines->blockSignals(true);
|
|
ui->window->blockSignals(true);
|
|
ui->average->blockSignals(true);
|
|
ui->overlap->blockSignals(true);
|
|
ui->unit->blockSignals(true);
|
|
|
|
if( ui->type->currentIndex() != _chart->type() )
|
|
ui->type->setCurrentIndex(_chart->type());
|
|
|
|
if( ui->frequency->value() != _chart->frequency() )
|
|
ui->frequency->setValue(_chart->frequency());
|
|
|
|
if( ui->resolution->value() != _chart->resolution() )
|
|
ui->resolution->setValue(_chart->resolution());
|
|
|
|
if( ui->lines->value() != (int) _chart->lines() )
|
|
ui->lines->setValue(_chart->lines());
|
|
|
|
if( ui->window->currentIndex() != _chart->window() )
|
|
ui->window->setCurrentIndex(_chart->window());
|
|
|
|
if( ui->average->value() != (int) _chart->average() )
|
|
ui->average->setValue(_chart->average());
|
|
|
|
if( ui->overlap->value() != (int) _chart->overlap() )
|
|
ui->overlap->setValue(_chart->overlap());
|
|
|
|
if( ui->unit->currentIndex() != _chart->unit() )
|
|
ui->unit->setCurrentIndex(_chart->unit());
|
|
|
|
|
|
ui->type->blockSignals(false);
|
|
ui->frequency->blockSignals(false);
|
|
ui->resolution->blockSignals(false);
|
|
ui->lines->blockSignals(false);
|
|
ui->window->blockSignals(false);
|
|
ui->average->blockSignals(false);
|
|
ui->overlap->blockSignals(false);
|
|
ui->unit->blockSignals(false);
|
|
}
|
|
|
|
void spec_widget::toogle_meas(bool enabled)
|
|
{
|
|
ui->tab_parameters->setVisible(enabled);
|
|
/*
|
|
if(_meas_widget)
|
|
{
|
|
if(enabled)
|
|
{
|
|
ui->meas_layout->addWidget(_meas_widget);
|
|
_meas_widget->show();
|
|
}
|
|
else
|
|
{
|
|
ui->meas_layout->removeWidget(_meas_widget);
|
|
_meas_widget->hide();
|
|
}
|
|
}
|
|
|
|
return;
|
|
*/
|
|
}
|
|
|
|
// void spec_widget::menu_request(const QPoint &pos)
|
|
// {
|
|
// QModelIndex index = ui->signals_->indexAt(pos);
|
|
|
|
// if(index.model()->data(index, Qt::CheckStateRole) == Qt::Checked)
|
|
// {
|
|
// _popup_node = static_cast<gtl::data_model_node*>(index.internalPointer());
|
|
// QMenu menu;
|
|
// menu.addAction(_spectrogramm_action);
|
|
// menu.exec(ui->signals_->viewport()->mapToGlobal(pos));
|
|
// }
|
|
// }
|
|
|
|
// void spec_widget::spectrogramm()
|
|
// {
|
|
// gtl::gui::spgr_widget* spgr = _chart->create_spgr(this, _popup_node);
|
|
// spgr->show();
|
|
// }
|
|
}
|
|
}
|