kopia lustrzana https://github.com/f4exb/sdrangel
419 wiersze
11 KiB
C++
419 wiersze
11 KiB
C++
///////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) 2018-2019 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
|
|
// //
|
|
// This program is free software; you can redistribute it and/or modify //
|
|
// it under the terms of the GNU General Public License as published by //
|
|
// the Free Software Foundation as version 3 of the License, or //
|
|
// (at your option) any later version. //
|
|
// //
|
|
// This program is distributed in the hope that it will be useful, //
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
|
// GNU General Public License V3 for more details. //
|
|
// //
|
|
// You should have received a copy of the GNU General Public License //
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include <math.h>
|
|
#include <QHBoxLayout>
|
|
|
|
#include "ui_arginfogui.h"
|
|
#include "arginfogui.h"
|
|
|
|
ArgInfoGUI::ArgInfoGUI(ArgInfoType type, ArgInfoValueType valueType, QWidget *parent) :
|
|
QWidget(parent),
|
|
ui(new Ui::ArgInfoGUI),
|
|
m_type(type),
|
|
m_valueType(valueType),
|
|
m_boolValue(false),
|
|
m_intValue(0),
|
|
m_floatValue(0.0),
|
|
m_hasRange(false),
|
|
m_minValue(0.0),
|
|
m_maxValue(0.0)
|
|
{
|
|
ui->setupUi(this);
|
|
QHBoxLayout *layout = ui->argLayout;
|
|
|
|
if ((m_valueType == ArgInfoValueInt) || (m_valueType == ArgInfoValueFloat))
|
|
{
|
|
if (m_type == ArgInfoContinuous) {
|
|
ui->argEdit->setAlignment(Qt::AlignRight);
|
|
} else if (m_type == ArgInfoDiscrete) {
|
|
ui->argCombo->setLayoutDirection(Qt::RightToLeft);
|
|
}
|
|
}
|
|
|
|
if (m_type != ArgInfoBinary)
|
|
{
|
|
layout->removeWidget(ui->argCheck);
|
|
delete ui->argCheck;
|
|
}
|
|
|
|
if (m_type != ArgInfoContinuous)
|
|
{
|
|
layout->removeWidget(ui->argEdit);
|
|
delete ui->argEdit;
|
|
}
|
|
|
|
if (m_type != ArgInfoDiscrete)
|
|
{
|
|
layout->removeWidget(ui->argCombo);
|
|
delete ui->argCombo;
|
|
}
|
|
}
|
|
|
|
ArgInfoGUI::~ArgInfoGUI()
|
|
{
|
|
delete ui;
|
|
}
|
|
|
|
void ArgInfoGUI::setRange(double min, double max)
|
|
{
|
|
m_hasRange = true;
|
|
m_minValue = min;
|
|
m_maxValue = max;
|
|
}
|
|
|
|
void ArgInfoGUI::setLabel(const QString& text)
|
|
{
|
|
ui->argLabel->setText(text);
|
|
}
|
|
|
|
void ArgInfoGUI::setToolTip(const QString& text)
|
|
{
|
|
if (m_type == ArgInfoBinary) {
|
|
ui->argCheck->setToolTip(text);
|
|
} else if (m_type == ArgInfoContinuous) {
|
|
ui->argEdit->setToolTip(text);
|
|
} else if (m_type == ArgInfoDiscrete) {
|
|
ui->argCombo->setToolTip(text);
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::setUnits(const QString& units)
|
|
{
|
|
ui->argUnits->setText(units);
|
|
}
|
|
|
|
void ArgInfoGUI::setBoolValue(bool value)
|
|
{
|
|
if (m_valueType == ArgInfoValueBool)
|
|
{
|
|
m_boolValue = value;
|
|
updateUIFromBool();
|
|
}
|
|
else if (m_valueType == ArgInfoValueInt)
|
|
{
|
|
m_intValue = setIntegerValue(value ? 1 : 0);
|
|
updateUIFromInt();
|
|
}
|
|
else if (m_valueType == ArgInfoValueFloat)
|
|
{
|
|
m_floatValue = setDoubleValue(value ? 1.0 : 0.0);
|
|
updateUIFromFloat();
|
|
}
|
|
else if (m_valueType == ArgInfoValueString)
|
|
{
|
|
m_stringValue = QString(value ? "true" : "false");
|
|
updateUIFromString();
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::addBoolValue(const QString& text, bool value)
|
|
{
|
|
if (m_type == ArgInfoDiscrete) {
|
|
ui->argCombo->addItem(text, QVariant(value));
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::setIntValue(int value)
|
|
{
|
|
if (m_valueType == ArgInfoValueBool)
|
|
{
|
|
m_boolValue = (value != 0);
|
|
updateUIFromBool();
|
|
}
|
|
else if (m_valueType == ArgInfoValueInt)
|
|
{
|
|
m_intValue = setIntegerValue(value);
|
|
updateUIFromInt();
|
|
}
|
|
else if (m_valueType == ArgInfoValueFloat)
|
|
{
|
|
m_floatValue = setDoubleValue(value);
|
|
updateUIFromFloat();
|
|
}
|
|
else if (m_valueType == ArgInfoValueString)
|
|
{
|
|
m_stringValue = QString("%1").arg(value);
|
|
updateUIFromString();
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::addIntValue(const QString& text, int value)
|
|
{
|
|
if (m_type == ArgInfoDiscrete) {
|
|
ui->argCombo->addItem(text, QVariant(setIntegerValue(value)));
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::setFloatValue(double value)
|
|
{
|
|
if (m_valueType == ArgInfoValueBool)
|
|
{
|
|
m_boolValue = (value != 0.0);
|
|
updateUIFromBool();
|
|
}
|
|
else if (m_valueType == ArgInfoValueInt)
|
|
{
|
|
m_intValue = setIntegerValue(value);
|
|
updateUIFromInt();
|
|
}
|
|
else if (m_valueType == ArgInfoValueFloat)
|
|
{
|
|
m_floatValue = setDoubleValue(value);
|
|
updateUIFromFloat();
|
|
}
|
|
else if (m_valueType == ArgInfoValueString)
|
|
{
|
|
m_stringValue = QString("%1").arg(value);
|
|
updateUIFromString();
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::addFloatValue(const QString& text, double value)
|
|
{
|
|
if (m_type == ArgInfoDiscrete) {
|
|
ui->argCombo->addItem(text, QVariant(setDoubleValue(value)));
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::setStringValue(const QString& value)
|
|
{
|
|
if (m_valueType == ArgInfoValueBool)
|
|
{
|
|
m_boolValue = (value == "true");
|
|
updateUIFromBool();
|
|
}
|
|
else if (m_valueType == ArgInfoValueInt)
|
|
{
|
|
int intValue = atoi(value.toStdString().c_str());
|
|
m_intValue = setIntegerValue(intValue);
|
|
updateUIFromInt();
|
|
}
|
|
else if (m_valueType == ArgInfoValueFloat)
|
|
{
|
|
double doubleValue = atof(value.toStdString().c_str());
|
|
m_floatValue = setDoubleValue(doubleValue);
|
|
updateUIFromFloat();
|
|
}
|
|
else if (m_valueType == ArgInfoValueString)
|
|
{
|
|
m_stringValue = value;
|
|
updateUIFromString();
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::addStringValue(const QString& text, const QString& value)
|
|
{
|
|
if (m_type == ArgInfoDiscrete) {
|
|
ui->argCombo->addItem(text, QVariant(value));
|
|
}
|
|
}
|
|
|
|
int ArgInfoGUI::setIntegerValue(int value)
|
|
{
|
|
if (m_hasRange) {
|
|
return value < round(m_minValue) ? round(m_minValue) : value > round(m_maxValue) ? round(m_maxValue) : value;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
double ArgInfoGUI::setDoubleValue(double value)
|
|
{
|
|
if (m_hasRange) {
|
|
return value < m_minValue ? m_minValue : value > m_maxValue ? m_maxValue : value;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::updateUIFromBool()
|
|
{
|
|
if (m_type == ArgInfoBinary)
|
|
{
|
|
ui->argCheck->blockSignals(true);
|
|
ui->argCheck->setChecked(m_boolValue);
|
|
ui->argCheck->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoContinuous)
|
|
{
|
|
ui->argEdit->blockSignals(true);
|
|
ui->argEdit->setText(QString(m_boolValue ? "true" : "false"));
|
|
ui->argEdit->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoDiscrete)
|
|
{
|
|
if (ui->argCombo->count() > 1)
|
|
{
|
|
ui->argCombo->blockSignals(true);
|
|
ui->argCombo->setCurrentIndex(m_boolValue ? 0 : 1);
|
|
ui->argCombo->blockSignals(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::updateUIFromInt()
|
|
{
|
|
if (m_type == ArgInfoBinary)
|
|
{
|
|
ui->argCheck->blockSignals(true);
|
|
ui->argCheck->setChecked(m_intValue == 0 ? false : true);
|
|
ui->argCheck->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoContinuous)
|
|
{
|
|
ui->argEdit->blockSignals(true);
|
|
ui->argEdit->setText(QString("%1").arg(m_intValue));
|
|
ui->argEdit->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoDiscrete)
|
|
{
|
|
for (int i = 0; i < ui->argCombo->count(); i++)
|
|
{
|
|
if (ui->argCombo->itemData(i).type() == QVariant::Int)
|
|
{
|
|
bool ok = false;
|
|
QVariant v = ui->argCombo->itemData(i);
|
|
|
|
if (m_intValue >= v.toInt(&ok) && ok)
|
|
{
|
|
ui->argCombo->blockSignals(true);
|
|
ui->argCombo->setCurrentIndex(i);
|
|
ui->argCombo->blockSignals(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::updateUIFromFloat()
|
|
{
|
|
if (m_type == ArgInfoBinary)
|
|
{
|
|
ui->argCheck->blockSignals(true);
|
|
ui->argCheck->setChecked(m_floatValue == 0.0 ? false : true);
|
|
ui->argCheck->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoContinuous)
|
|
{
|
|
ui->argEdit->blockSignals(true);
|
|
ui->argEdit->setText(QString("%1").arg(m_floatValue));
|
|
ui->argEdit->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoDiscrete)
|
|
{
|
|
for (int i = 0; i < ui->argCombo->count(); i++)
|
|
{
|
|
if (ui->argCombo->itemData(i).type() == QVariant::Double)
|
|
{
|
|
bool ok = false;
|
|
QVariant v = ui->argCombo->itemData(i);
|
|
|
|
if (m_floatValue >= v.toDouble(&ok) && ok)
|
|
{
|
|
ui->argCombo->blockSignals(true);
|
|
ui->argCombo->setCurrentIndex(i);
|
|
ui->argCombo->blockSignals(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::updateUIFromString()
|
|
{
|
|
if (m_type == ArgInfoBinary)
|
|
{
|
|
ui->argCheck->blockSignals(true);
|
|
ui->argCheck->setChecked(m_stringValue == "true" ? true : false);
|
|
ui->argCheck->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoContinuous)
|
|
{
|
|
ui->argEdit->blockSignals(true);
|
|
ui->argEdit->setText(m_stringValue);
|
|
ui->argEdit->blockSignals(false);
|
|
}
|
|
else if (m_type == ArgInfoDiscrete)
|
|
{
|
|
for (int i = 0; i < ui->argCombo->count(); i++)
|
|
{
|
|
if (ui->argCombo->itemData(i).type() == QVariant::String)
|
|
{
|
|
QVariant v = ui->argCombo->itemData(i);
|
|
|
|
if (m_stringValue == v.toString())
|
|
{
|
|
ui->argCombo->blockSignals(true);
|
|
ui->argCombo->setCurrentIndex(i);
|
|
ui->argCombo->blockSignals(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ArgInfoGUI::on_argCheck_toggled(bool checked)
|
|
{
|
|
setBoolValue(checked);
|
|
emit valueChanged();
|
|
}
|
|
|
|
void ArgInfoGUI::on_argEdit_editingFinished()
|
|
{
|
|
setStringValue(ui->argEdit->text());
|
|
emit valueChanged();
|
|
}
|
|
|
|
void ArgInfoGUI::on_argCombo_currentIndexChanged(int index)
|
|
{
|
|
(void) index;
|
|
QVariant v = ui->argCombo->currentData();
|
|
bool ok = false;
|
|
|
|
if (v.type() == QVariant::Bool)
|
|
{
|
|
setBoolValue(v.toBool());
|
|
emit valueChanged();
|
|
}
|
|
else if (v.type() == QVariant::Int)
|
|
{
|
|
setIntValue(v.toInt(&ok));
|
|
|
|
if (ok) {
|
|
emit valueChanged();
|
|
}
|
|
}
|
|
else if (v.type() == QVariant::Double)
|
|
{
|
|
setFloatValue(v.toDouble(&ok));
|
|
|
|
if (ok) {
|
|
emit valueChanged();
|
|
}
|
|
}
|
|
else if (v.type() ==QVariant::String)
|
|
{
|
|
setStringValue(v.toString());
|
|
emit valueChanged();
|
|
}
|
|
}
|
|
|