298 lines
13 KiB
C++
298 lines
13 KiB
C++
|
|
#include <QSizePolicy>
|
|
#include <QJsonDocument>
|
|
|
|
#include "gtl_gui_config_widget_analog.h"
|
|
#include "ui_gtl_gui_config_widget_analog.h"
|
|
|
|
#include "hw/gtl_analog_input.h"
|
|
#include "hw/gtl_hw_generator_analog_input.h"
|
|
#include "hw/gtl_hw_player_analog_input.h"
|
|
#include "math/gtl_math_intg.h"
|
|
#include "math/gtl_math_diff.h"
|
|
#include "gui/gtl_gui_chart_widget.h"
|
|
|
|
namespace gtl
|
|
{
|
|
namespace gui
|
|
{
|
|
namespace config
|
|
{
|
|
widget_analog::widget_analog(QWidget *parent) :
|
|
widget_node(parent),
|
|
ui(new Ui::config_widget_analog),
|
|
_filter_info(new gtl::math::filter_iir_info())
|
|
{
|
|
ui->setupUi(this);
|
|
_color = new color_box(this);
|
|
_color->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
|
|
ui->color_layout->setWidget(0, QFormLayout::ItemRole::FieldRole, _color);
|
|
|
|
_filter_response_chart = new config::filter_response_chart(this);
|
|
ui->page_3->layout()->addWidget(new gtl::gui::chart_widget(_filter_response_chart));
|
|
}
|
|
|
|
widget_analog::~widget_analog()
|
|
{
|
|
delete ui;
|
|
delete _filter_info;
|
|
}
|
|
|
|
void widget_analog::set_node(data_model_node *node)
|
|
{
|
|
_color->disconnect();
|
|
_color->set_color(static_cast<gtl::analog_data*>(node)->color());
|
|
connect(_color, &color_box::icolor_changed, static_cast<gtl::analog_data*>(node), >l::analog_data::set_color);
|
|
|
|
QString class_name(node->metaObject()->className());
|
|
if(class_name == "gtl::hw::analog_input")
|
|
{
|
|
gtl::hw::analog_input* input = static_cast<gtl::hw::analog_input*>(node);
|
|
ui->stackedWidget->setCurrentIndex(0);
|
|
|
|
ui->sensitivity->disconnect();
|
|
ui->sensitivity->setValue(input->sensitivity());
|
|
connect(ui->sensitivity, &QDoubleSpinBox::valueChanged, input, >l::hw::analog_input::set_sensitivity);
|
|
|
|
ui->gain->disconnect();
|
|
ui->gain->setValue(input->gain());
|
|
connect(ui->gain, &QDoubleSpinBox::valueChanged, input, >l::hw::analog_input::set_gain);
|
|
|
|
ui->offset->disconnect();
|
|
ui->offset->setValue(input->offset());
|
|
connect(ui->offset, &QDoubleSpinBox::valueChanged, input, >l::hw::analog_input::set_offset);
|
|
|
|
ui->reference->disconnect();
|
|
ui->reference->setValue(input->reference());
|
|
connect(ui->reference, &QDoubleSpinBox::valueChanged, input, >l::hw::analog_input::set_reference);
|
|
|
|
ui->iepe->disconnect();
|
|
ui->iepe->setChecked(input->is_iepe());
|
|
connect(ui->iepe, &QCheckBox::stateChanged, input, >l::hw::analog_input::set_iepe);
|
|
|
|
ui->coupling->disconnect();
|
|
ui->coupling->setCurrentIndex(input->is_coupling());
|
|
connect(ui->coupling, &QComboBox::currentIndexChanged, input, >l::hw::analog_input::set_coupling);
|
|
|
|
ui->inverse->disconnect();
|
|
ui->inverse->setChecked(input->is_inverting());
|
|
connect(ui->inverse, &QCheckBox::stateChanged, input, >l::hw::analog_input::set_inverting);
|
|
}
|
|
else if(class_name == "gtl::hw::generator_analog_input")
|
|
{
|
|
gtl::hw::generator_analog_input* input = static_cast<gtl::hw::generator_analog_input*>(node);
|
|
ui->stackedWidget->setCurrentIndex(1);
|
|
|
|
ui->freq->disconnect();
|
|
ui->freq->setValue(input->freq());
|
|
connect(ui->freq, &QDoubleSpinBox::valueChanged, input, >l::hw::generator_analog_input::set_freq);
|
|
|
|
ui->phase->disconnect();
|
|
ui->phase->setValue(input->phase());
|
|
connect(ui->phase, &QDoubleSpinBox::valueChanged, input, >l::hw::generator_analog_input::set_phase);
|
|
|
|
}
|
|
else if(class_name == "gtl::math::filter_iir")
|
|
{
|
|
_filter = static_cast<gtl::math::filter_iir*>(node);
|
|
|
|
ui->stackedWidget->setCurrentIndex(2);
|
|
|
|
ui->filter_frequency->disconnect();
|
|
ui->filter_frequency->setValue(_filter->frequency());
|
|
connect(ui->filter_frequency, &QDoubleSpinBox::valueChanged, _filter, >l::math::filter_iir::set_frequency);
|
|
|
|
ui->filter_order->disconnect();
|
|
ui->filter_order->setValue(_filter->order());
|
|
connect(ui->filter_order, &QSpinBox::valueChanged, _filter, >l::math::filter_iir::set_order);
|
|
|
|
ui->filter_gain->disconnect();
|
|
ui->filter_gain->setValue(_filter->gain());
|
|
connect(ui->filter_gain, &QDoubleSpinBox::valueChanged, _filter, >l::math::filter_iir::set_gain);
|
|
|
|
ui->filter_width->disconnect();
|
|
ui->filter_width->setValue(_filter->width());
|
|
connect(ui->filter_width, &QDoubleSpinBox::valueChanged, _filter, >l::math::filter_iir::set_width);
|
|
|
|
ui->filter_slope->disconnect();
|
|
ui->filter_slope->setValue(_filter->slope());
|
|
connect(ui->filter_slope, &QDoubleSpinBox::valueChanged, _filter, >l::math::filter_iir::set_slope);
|
|
|
|
ui->filter_q->disconnect();
|
|
ui->filter_q->setValue(_filter->q());
|
|
connect(ui->filter_q, &QDoubleSpinBox::valueChanged, _filter, >l::math::filter_iir::set_q);
|
|
|
|
ui->filter_ripple->disconnect();
|
|
ui->filter_ripple->setValue(_filter->ripple());
|
|
connect(ui->filter_ripple, &QDoubleSpinBox::valueChanged, _filter, >l::math::filter_iir::set_ripple);
|
|
|
|
ui->filter_stop->disconnect();
|
|
ui->filter_stop->setValue(_filter->stop());
|
|
connect(ui->filter_stop, &QDoubleSpinBox::valueChanged, _filter, >l::math::filter_iir::set_stop);
|
|
|
|
/// set kind ///
|
|
ui->filter_kind->disconnect();
|
|
ui->filter_kind->clear();
|
|
|
|
for (QDomNode dom = _filter_info->info().firstChild();
|
|
!dom.isNull();
|
|
dom = dom.nextSibling())
|
|
{
|
|
if (dom.isElement())
|
|
{
|
|
ui->filter_kind->addItem(dom.nodeName());
|
|
if( _filter->kind() == _filter_info->kind(dom.nodeName()))
|
|
ui->filter_kind->setCurrentIndex(ui->filter_kind->count() - 1);
|
|
}
|
|
|
|
}
|
|
|
|
connect(ui->filter_kind, &QComboBox::currentIndexChanged, this, &widget_analog::filter_kind_changed);
|
|
filter_kind_changed();
|
|
|
|
|
|
_filter_response_chart->set_filter(_filter);
|
|
///////////////
|
|
}
|
|
else if(class_name == "gtl::math::intg")
|
|
{
|
|
gtl::math::intg* intg = static_cast<gtl::math::intg*>(node);
|
|
ui->stackedWidget->setCurrentIndex(3);
|
|
|
|
ui->intg_taps->disconnect();
|
|
ui->intg_taps->setValue(intg->taps());
|
|
connect(ui->intg_taps, &QSpinBox::valueChanged, intg, >l::math::intg::set_taps);
|
|
|
|
}
|
|
else if(class_name == "gtl::math::diff")
|
|
{
|
|
gtl::math::diff* diff = static_cast<gtl::math::diff*>(node);
|
|
ui->stackedWidget->setCurrentIndex(4);
|
|
|
|
ui->diff_taps->disconnect();
|
|
ui->diff_taps->setValue(diff->taps());
|
|
connect(ui->diff_taps, &QSpinBox::valueChanged, diff, >l::math::diff::set_taps);
|
|
}
|
|
else if(class_name == "gtl::hw::player_analog_input")
|
|
{
|
|
ui->player_analog_input_info->setPlainText(QJsonDocument(static_cast<gtl::hw::player_analog_input*>(node)->info()).toJson());
|
|
ui->stackedWidget->setCurrentIndex(5);
|
|
}
|
|
|
|
}
|
|
|
|
void widget_analog::set_color_visible(bool value)
|
|
{
|
|
ui->color_label->setVisible(value);
|
|
_color->setVisible(value);
|
|
}
|
|
|
|
void widget_analog::filter_kind_changed()
|
|
{
|
|
if(_filter)
|
|
{
|
|
QString name = ui->filter_kind->currentText();
|
|
|
|
ui->filter_type->disconnect();
|
|
ui->filter_type->clear();
|
|
|
|
QDomNode kind = _filter_info->info().namedItem(name);
|
|
for (QDomNode type = kind.firstChild();
|
|
!type.isNull();
|
|
type = type.nextSibling())
|
|
{
|
|
if (type.isElement())
|
|
{
|
|
ui->filter_type->addItem(type.nodeName());
|
|
if(_filter_info->type(type.nodeName()) == _filter->type())
|
|
ui->filter_type->setCurrentIndex(ui->filter_type->count() - 1);
|
|
}
|
|
}
|
|
_filter->set_kind(_filter_info->kind(name));
|
|
}
|
|
|
|
connect(ui->filter_type, &QComboBox::currentIndexChanged, this, &widget_analog::filter_type_changed);
|
|
filter_type_changed();
|
|
|
|
}
|
|
|
|
|
|
void widget_analog::filter_type_changed()
|
|
{
|
|
if(_filter)
|
|
{
|
|
filter_show_property("none");
|
|
QDomNode kind = _filter_info->info().namedItem(ui->filter_kind->currentText());
|
|
QDomElement type = kind.namedItem(ui->filter_type->currentText()).toElement();
|
|
|
|
if(type.hasAttributes())
|
|
for(int i = 0; i < 6; i++)
|
|
{
|
|
QString prop = type.attribute(QString::number(i));
|
|
if(prop != "")
|
|
filter_show_property(prop);
|
|
else
|
|
break;
|
|
}
|
|
_filter->set_type(_filter_info->type(ui->filter_type->currentText()));
|
|
}
|
|
}
|
|
|
|
void widget_analog::filter_show_property(QString property)
|
|
{
|
|
if(property == QString("gain"))
|
|
{
|
|
ui->filter_gain_label->setVisible(true);
|
|
ui->filter_gain->setVisible(true);
|
|
ui->filter_gain->setValue(_filter->gain());
|
|
}
|
|
else if(property == QString("q"))
|
|
{
|
|
ui->filter_q_label->setVisible(true);
|
|
ui->filter_q->setVisible(true);
|
|
ui->filter_q->setValue(_filter->q());
|
|
}
|
|
else if(property == QString("ripple"))
|
|
{
|
|
ui->filter_ripple_label->setVisible(true);
|
|
ui->filter_ripple->setVisible(true);
|
|
ui->filter_ripple->setValue(_filter->ripple());
|
|
}
|
|
else if(property == QString("slope"))
|
|
{
|
|
ui->filter_slope_label->setVisible(true);
|
|
ui->filter_slope->setVisible(true);
|
|
ui->filter_slope->setValue(_filter->slope());
|
|
}
|
|
else if(property == QString("stop"))
|
|
{
|
|
ui->filter_stop_label->setVisible(true);
|
|
ui->filter_stop->setVisible(true);
|
|
ui->filter_stop->setValue(_filter->stop());
|
|
}
|
|
else if(property == QString("width"))
|
|
{
|
|
ui->filter_width_label->setVisible(true);
|
|
ui->filter_width->setVisible(true);
|
|
ui->filter_width->setValue(_filter->width());
|
|
}
|
|
else
|
|
{
|
|
ui->filter_gain_label->setVisible(false);
|
|
ui->filter_gain->setVisible(false);
|
|
ui->filter_q_label->setVisible(false);
|
|
ui->filter_q->setVisible(false);
|
|
ui->filter_ripple_label->setVisible(false);
|
|
ui->filter_ripple->setVisible(false);
|
|
ui->filter_slope_label->setVisible(false);
|
|
ui->filter_slope->setVisible(false);
|
|
ui->filter_stop_label->setVisible(false);
|
|
ui->filter_stop->setVisible(false);
|
|
ui->filter_width_label->setVisible(false);
|
|
ui->filter_width->setVisible(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|