1560 lines
42 KiB
C++
1560 lines
42 KiB
C++
/*
|
|
Original copyright 2018 Benjamin Vedder benjamin@vedder.se and the VESC Tool project ( https://github.com/vedderb/vesc_tool )
|
|
|
|
Forked to:
|
|
Copyright 2018 Danny Bokma github@diebie.nl (https://github.com/DieBieEngineering/DieBieMS-Tool)
|
|
|
|
Now forked to:
|
|
Copyright 2019 - 2020 Kevin Dionne kevin.dionne@ennoid.me (https://github.com/EnnoidMe/ENNOID-BMS-Tool)
|
|
|
|
This file is part of ENNOID-BMS Tool.
|
|
|
|
ENNOID-BMS Tool 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, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
ENNOID-BMS Tool 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 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 "configparams.h"
|
|
#include <QDebug>
|
|
#include "widgets/parameditdouble.h"
|
|
#include "widgets/parameditint.h"
|
|
#include "widgets/parameditstring.h"
|
|
#include "widgets/parameditenum.h"
|
|
#include "widgets/parameditbool.h"
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QBuffer>
|
|
#include <cmath>
|
|
#include "utility.h"
|
|
|
|
ConfigParams::ConfigParams(QObject *parent) : QObject(parent)
|
|
{
|
|
mUpdateOnlyName.clear();
|
|
mXmlStatus = tr("OK");
|
|
mUpdatesEnabled = true;
|
|
}
|
|
|
|
void ConfigParams::addParam(const QString &name, ConfigParam param)
|
|
{
|
|
if (!mParams.contains(name)) {
|
|
|
|
mParams.insert(name, param);
|
|
mParamList.append(name);
|
|
} else {
|
|
qWarning() << name << "already present.";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::deleteParam(const QString &name)
|
|
{
|
|
mParams.remove(name);
|
|
for (int i = 0;i < mParamList.size();i++) {
|
|
if (mParamList.at(i) == name) {
|
|
mParamList.removeAt(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief ConfigParams::setUpdateOnly
|
|
* Only update parameter with the following name.
|
|
*
|
|
* @param name
|
|
* The name of the parameter to update. If empty all parameters will be updated.
|
|
*/
|
|
void ConfigParams::setUpdateOnly(const QString &name)
|
|
{
|
|
mUpdateOnlyName = name;
|
|
}
|
|
|
|
QString ConfigParams::getUpdateOnly()
|
|
{
|
|
return mUpdateOnlyName;
|
|
}
|
|
|
|
bool ConfigParams::getUpdatesEnabled() const
|
|
{
|
|
return mUpdatesEnabled;
|
|
}
|
|
|
|
void ConfigParams::setUpdatesEnabled(bool updatesEnabled)
|
|
{
|
|
mUpdatesEnabled = updatesEnabled;
|
|
}
|
|
|
|
void ConfigParams::clearParams()
|
|
{
|
|
mParams.clear();
|
|
mParamList.clear();
|
|
}
|
|
|
|
void ConfigParams::clearAll()
|
|
{
|
|
clearParams();
|
|
clearSerializeOrder();
|
|
}
|
|
|
|
bool ConfigParams::hasParam(const QString &name)
|
|
{
|
|
return mParams.contains(name);
|
|
}
|
|
|
|
ConfigParam *ConfigParams::getParam(const QString &name)
|
|
{
|
|
ConfigParam *retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = &mParams[name];
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
ConfigParam ConfigParams::getParamCopy(const QString &name) const
|
|
{
|
|
ConfigParam retVal;
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams.value(name);
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
bool ConfigParams::isParamDouble(const QString &name)
|
|
{
|
|
if (mParams.contains(name) && mParams[name].type == CFG_T_DOUBLE) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ConfigParams::isParamInt(const QString &name)
|
|
{
|
|
if (mParams.contains(name) && mParams[name].type == CFG_T_INT) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ConfigParams::isParamEnum(const QString &name)
|
|
{
|
|
if (mParams.contains(name) && mParams[name].type == CFG_T_ENUM) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ConfigParams::isParamQString(const QString &name)
|
|
{
|
|
if (mParams.contains(name) && mParams[name].type == CFG_T_QSTRING) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ConfigParams::isParamBool(const QString &name)
|
|
{
|
|
if (mParams.contains(name) && mParams[name].type == CFG_T_BOOL) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
double ConfigParams::getParamDouble(const QString &name)
|
|
{
|
|
double retVal = 0.0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_DOUBLE) {
|
|
retVal = p.valDouble;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
int ConfigParams::getParamInt(const QString &name)
|
|
{
|
|
int retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_INT) {
|
|
retVal = p.valInt;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
int ConfigParams::getParamEnum(const QString &name)
|
|
{
|
|
int retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_ENUM) {
|
|
retVal = p.valInt;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
QString ConfigParams::getParamQString(const QString &name)
|
|
{
|
|
QString retVal = "";
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_QSTRING) {
|
|
retVal = p.valString;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
bool ConfigParams::getParamBool(const QString &name)
|
|
{
|
|
bool retVal = false;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_BOOL) {
|
|
retVal = p.valInt;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
QString ConfigParams::getLongName(const QString &name)
|
|
{
|
|
QString retVal = "";
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams[name].longName;
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
QString ConfigParams::getDescription(const QString &name)
|
|
{
|
|
QString retVal = "";
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams[name].description;
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
double ConfigParams::getParamMaxDouble(const QString &name)
|
|
{
|
|
double retVal = 0.0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_DOUBLE) {
|
|
retVal = p.maxDouble;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
double ConfigParams::getParamMinDouble(const QString &name)
|
|
{
|
|
double retVal = 0.0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_DOUBLE) {
|
|
retVal = p.minDouble;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
double ConfigParams::getParamStepDouble(const QString &name)
|
|
{
|
|
double retVal = 0.0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_DOUBLE) {
|
|
retVal = p.stepDouble;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
int ConfigParams::getParamDecimalsDouble(const QString &name)
|
|
{
|
|
int retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_DOUBLE) {
|
|
retVal = p.editorDecimalsDouble;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
int ConfigParams::getParamMaxInt(const QString &name)
|
|
{
|
|
int retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_INT) {
|
|
retVal = p.maxInt;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
int ConfigParams::getParamMinInt(const QString &name)
|
|
{
|
|
int retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_INT) {
|
|
retVal = p.minInt;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
int ConfigParams::getParamStepInt(const QString &name)
|
|
{
|
|
int retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_INT) {
|
|
retVal = p.stepInt;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
QStringList ConfigParams::getParamEnumNames(const QString &name)
|
|
{
|
|
QStringList retVal;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (p.type == CFG_T_ENUM) {
|
|
retVal = p.enumNames;
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
double ConfigParams::getParamEditorScale(const QString &name)
|
|
{
|
|
double retVal = 0.0;
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams[name].editorScale;
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
QString ConfigParams::getParamSuffix(const QString &name)
|
|
{
|
|
QString retVal = "";
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams[name].suffix;
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
bool ConfigParams::getParamEditAsPercentage(const QString &name)
|
|
{
|
|
bool retVal = false;
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams[name].editAsPercentage;
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
bool ConfigParams::getParamShowDisplay(const QString &name)
|
|
{
|
|
bool retVal = false;
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams[name].showDisplay;
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
bool ConfigParams::getParamTransmittable(const QString &name)
|
|
{
|
|
bool retVal = false;
|
|
|
|
if (mParams.contains(name)) {
|
|
retVal = mParams[name].transmittable;
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
QStringList ConfigParams::getParamOrder() const
|
|
{
|
|
return mParamList;
|
|
}
|
|
|
|
void ConfigParams::setParamOrder(const QStringList &order)
|
|
{
|
|
// TODO: Add check to make sure that the new order is valid.
|
|
mParamList = order;
|
|
}
|
|
|
|
void ConfigParams::setParamValue(const QString &name, QVariant val)
|
|
{
|
|
ConfigParam *retVal = 0;
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (mParams.contains(name)) {
|
|
p.suffix;
|
|
p.editorDecimalsDouble;
|
|
p.editAsPercentage;
|
|
p.showDisplay;
|
|
|
|
//int(p.type);
|
|
switch (p.type) {
|
|
case CFG_T_QSTRING: {
|
|
p.valString = val.toString();
|
|
}
|
|
break;
|
|
|
|
case CFG_T_DOUBLE: {
|
|
p.valDouble = val.toDouble();
|
|
}
|
|
break;
|
|
|
|
case CFG_T_ENUM:
|
|
case CFG_T_BOOL:
|
|
case CFG_T_INT: {
|
|
if(val.type() == QVariant::Bool)
|
|
p.valInt = val.toBool() ? 1 : 0;
|
|
else
|
|
p.valInt = val.toInt();
|
|
}
|
|
break;
|
|
}
|
|
|
|
//edit->setProperty("type", int(p.type));
|
|
//edit->setProperty("suffix", p.suffix);
|
|
//edit->setProperty("editorDecimalsDouble", p.editorDecimalsDouble);
|
|
//edit->setProperty("editAsPercentage", p.editAsPercentage);
|
|
//edit->setProperty("value", p.valDouble);
|
|
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
|
|
QWidget *ConfigParams::getEditor(const QString &name, QWidget *parent)
|
|
{
|
|
QWidget *retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
switch (p.type) {
|
|
case CFG_T_DOUBLE: {
|
|
ParamEditDouble *edit = new ParamEditDouble(parent);
|
|
edit->setName(name);
|
|
edit->setSuffix(p.suffix);
|
|
edit->setDecimals(p.editorDecimalsDouble);
|
|
edit->setShowAsPercentage(p.editAsPercentage);
|
|
edit->showDisplay(p.showDisplay);
|
|
|
|
edit->setProperty("type", int(p.type));
|
|
edit->setProperty("suffix", p.suffix);
|
|
edit->setProperty("editorDecimalsDouble", p.editorDecimalsDouble);
|
|
edit->setProperty("editAsPercentage", p.editAsPercentage);
|
|
edit->setProperty("value", p.valDouble);
|
|
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_INT: {
|
|
ParamEditInt *edit = new ParamEditInt(parent);
|
|
edit->setName(name);
|
|
edit->setSuffix(p.suffix);
|
|
edit->setShowAsPercentage(p.editAsPercentage);
|
|
edit->showDisplay(p.showDisplay);
|
|
|
|
edit->setProperty("type", int(p.type));
|
|
edit->setProperty("suffix", p.suffix);
|
|
edit->setProperty("editorDecimalsDouble", p.editorDecimalsDouble);
|
|
edit->setProperty("editAsPercentage", p.editAsPercentage);
|
|
edit->setProperty("value", p.valInt);
|
|
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_QSTRING: {
|
|
ParamEditString *edit = new ParamEditString(parent);
|
|
edit->setName(name);
|
|
|
|
edit->setProperty("type", int(p.type));
|
|
edit->setProperty("suffix", p.suffix);
|
|
edit->setProperty("editorDecimalsDouble", p.editorDecimalsDouble);
|
|
edit->setProperty("editAsPercentage", p.editAsPercentage);
|
|
edit->setProperty("value", p.valString);
|
|
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_ENUM: {
|
|
ParamEditEnum *edit = new ParamEditEnum(parent);
|
|
edit->setName(name);
|
|
|
|
edit->setProperty("type", int(p.type));
|
|
edit->setProperty("suffix", p.suffix);
|
|
edit->setProperty("editorDecimalsDouble", p.editorDecimalsDouble);
|
|
edit->setProperty("editAsPercentage", p.editAsPercentage);
|
|
edit->setProperty("value", p.valInt);
|
|
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_BOOL: {
|
|
ParamEditBool *edit = new ParamEditBool(parent);
|
|
edit->setName(name);
|
|
|
|
edit->setProperty("type", int(p.type));
|
|
edit->setProperty("suffix", p.suffix);
|
|
edit->setProperty("editorDecimalsDouble", p.editorDecimalsDouble);
|
|
edit->setProperty("editAsPercentage", p.editAsPercentage);
|
|
edit->setProperty("value", p.valInt);
|
|
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
default:
|
|
qWarning() << "no editor for" << name << "could be created";
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/*
|
|
QWidget *ConfigParams::getEditor(const QString &name, QWidget *parent)
|
|
{
|
|
QWidget *retVal = 0;
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
switch (p.type) {
|
|
case CFG_T_DOUBLE: {
|
|
ParamEditDouble *edit = new ParamEditDouble(parent);
|
|
edit->setName(name);
|
|
edit->setSuffix(p.suffix);
|
|
edit->setDecimals(p.editorDecimalsDouble);
|
|
edit->setShowAsPercentage(p.editAsPercentage);
|
|
edit->showDisplay(p.showDisplay);
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_INT: {
|
|
ParamEditInt *edit = new ParamEditInt(parent);
|
|
edit->setName(name);
|
|
edit->setSuffix(p.suffix);
|
|
edit->setShowAsPercentage(p.editAsPercentage);
|
|
edit->showDisplay(p.showDisplay);
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_QSTRING: {
|
|
ParamEditString *edit = new ParamEditString(parent);
|
|
edit->setName(name);
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_ENUM: {
|
|
ParamEditEnum *edit = new ParamEditEnum(parent);
|
|
edit->setName(name);
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
case CFG_T_BOOL: {
|
|
ParamEditBool *edit = new ParamEditBool(parent);
|
|
edit->setName(name);
|
|
edit->setConfig(this);
|
|
retVal = edit;
|
|
} break;
|
|
|
|
default:
|
|
qWarning() << "no editor for" << name << "could be created";
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
void ConfigParams::getParamSerial(VByteArray &vb, const QString &name)
|
|
{
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
switch (p.type) {
|
|
case CFG_T_UNDEFINED:
|
|
qWarning() << name << ": type not defined.";
|
|
break;
|
|
|
|
case CFG_T_DOUBLE:
|
|
if (p.vTx == VESC_TX_DOUBLE16) {
|
|
vb.vbAppendDouble16(p.valDouble, p.vTxDoubleScale);
|
|
} else if (p.vTx == VESC_TX_DOUBLE32) {
|
|
vb.vbAppendDouble32(p.valDouble, p.vTxDoubleScale);
|
|
} else if (p.vTx == VESC_TX_DOUBLE32_AUTO) {
|
|
vb.vbAppendDouble32Auto(p.valDouble);
|
|
} else {
|
|
qWarning() << name << ": wrong tx type set.";
|
|
}
|
|
break;
|
|
|
|
case CFG_T_INT:
|
|
if (p.vTx == VESC_TX_UINT8) {
|
|
vb.vbAppendUint8(p.valInt);
|
|
} else if (p.vTx == VESC_TX_INT8) {
|
|
vb.vbAppendInt8(p.valInt);
|
|
} else if (p.vTx == VESC_TX_UINT16) {
|
|
vb.vbAppendUint16(p.valInt);
|
|
} else if (p.vTx == VESC_TX_INT16) {
|
|
vb.vbAppendInt16(p.valInt);
|
|
} else if (p.vTx == VESC_TX_UINT32) {
|
|
vb.vbAppendUint32(p.valInt);
|
|
} else if (p.vTx == VESC_TX_INT32) {
|
|
vb.vbAppendInt32(p.valInt);
|
|
} else {
|
|
qWarning() << name << ": wrong tx type set.";
|
|
}
|
|
break;
|
|
|
|
case CFG_T_QSTRING:
|
|
qWarning() << name << ": QString not supported.";
|
|
break;
|
|
|
|
case CFG_T_ENUM:
|
|
case CFG_T_BOOL:
|
|
vb.vbAppendInt8(p.valInt);
|
|
break;
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::setParamSerial(VByteArray &vb, const QString &name, QObject *src)
|
|
{
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
switch (p.type) {
|
|
case CFG_T_UNDEFINED:
|
|
qWarning() << name << ": type not defined.";
|
|
break;
|
|
|
|
case CFG_T_DOUBLE: {
|
|
double val = 0.0;
|
|
if (p.vTx == VESC_TX_DOUBLE16) {
|
|
val = vb.vbPopFrontDouble16(p.vTxDoubleScale);
|
|
} else if (p.vTx == VESC_TX_DOUBLE32) {
|
|
val = vb.vbPopFrontDouble32(p.vTxDoubleScale);
|
|
} else if (p.vTx == VESC_TX_DOUBLE32_AUTO) {
|
|
val = vb.vbPopFrontDouble32Auto();
|
|
} else {
|
|
qWarning() << name << ": wrong tx type set.";
|
|
}
|
|
|
|
if (mUpdatesEnabled && (mUpdateOnlyName.isEmpty() || mUpdateOnlyName == name)) {
|
|
if (p.valDouble != val) {
|
|
p.valDouble = val;
|
|
emit paramChangedDouble(src, name, val);
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case CFG_T_INT: {
|
|
int val = 0;
|
|
|
|
if (p.vTx == VESC_TX_UINT8) {
|
|
val = vb.vbPopFrontUint8();
|
|
} else if (p.vTx == VESC_TX_INT8) {
|
|
val = vb.vbPopFrontInt8();
|
|
} else if (p.vTx == VESC_TX_UINT16) {
|
|
val = vb.vbPopFrontUint16();
|
|
} else if (p.vTx == VESC_TX_INT16) {
|
|
val = vb.vbPopFrontInt16();
|
|
} else if (p.vTx == VESC_TX_UINT32) {
|
|
val = vb.vbPopFrontUint32();
|
|
} else if (p.vTx == VESC_TX_INT32) {
|
|
val = vb.vbPopFrontInt32();
|
|
} else {
|
|
qWarning() << name << ": wrong tx type set.";
|
|
}
|
|
|
|
if (mUpdatesEnabled && (mUpdateOnlyName.isEmpty() || mUpdateOnlyName == name)) {
|
|
if (p.valInt != val) {
|
|
p.valInt = val;
|
|
emit paramChangedInt(src, name, val);
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case CFG_T_QSTRING:
|
|
qWarning() << name << ": QString not supported.";
|
|
break;
|
|
|
|
case CFG_T_ENUM:
|
|
case CFG_T_BOOL: {
|
|
int val = vb.vbPopFrontInt8();
|
|
|
|
if (mUpdatesEnabled && (mUpdateOnlyName.isEmpty() || mUpdateOnlyName == name)) {
|
|
if (p.valInt != val) {
|
|
p.valInt = val;
|
|
if (p.type == CFG_T_BOOL) {
|
|
emit paramChangedBool(src, name, val);
|
|
} else {
|
|
emit paramChangedEnum(src, name, val);
|
|
}
|
|
}
|
|
}
|
|
} break;
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::updateParamDouble(QString name, double param, QObject *src)
|
|
{
|
|
if (!mUpdatesEnabled || (!mUpdateOnlyName.isEmpty() && mUpdateOnlyName != name)) {
|
|
return;
|
|
}
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
if (p.type == CFG_T_DOUBLE) {
|
|
if (p.valDouble != param) {
|
|
p.valDouble = param;
|
|
emit paramChangedDouble(src, name, param);
|
|
}
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::updateParamInt(QString name, int param, QObject *src)
|
|
{
|
|
if (!mUpdatesEnabled || (!mUpdateOnlyName.isEmpty() && mUpdateOnlyName != name)) {
|
|
return;
|
|
}
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
if (p.type == CFG_T_INT) {
|
|
if (p.valInt != param) {
|
|
p.valInt = param;
|
|
emit paramChangedInt(src, name, param);
|
|
}
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::updateParamEnum(QString name, int param, QObject *src)
|
|
{
|
|
if (!mUpdatesEnabled || (!mUpdateOnlyName.isEmpty() && mUpdateOnlyName != name)) {
|
|
return;
|
|
}
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
if (p.type == CFG_T_ENUM) {
|
|
if (p.valInt != param) {
|
|
p.valInt = param;
|
|
emit paramChangedEnum(src, name, param);
|
|
}
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::updateParamString(QString name, QString param, QObject *src)
|
|
{
|
|
if (!mUpdatesEnabled || (!mUpdateOnlyName.isEmpty() && mUpdateOnlyName != name)) {
|
|
return;
|
|
}
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
if (p.type == CFG_T_QSTRING) {
|
|
if (p.valString != param) {
|
|
p.valString = param;
|
|
emit paramChangedQString(src, name, param);
|
|
}
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::updateParamBool(QString name, bool param, QObject *src)
|
|
{
|
|
if (!mUpdatesEnabled || (!mUpdateOnlyName.isEmpty() && mUpdateOnlyName != name)) {
|
|
return;
|
|
}
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
if (p.type == CFG_T_BOOL) {
|
|
if (p.valInt != param) {
|
|
p.valInt = param;
|
|
emit paramChangedBool(src, name, param);
|
|
}
|
|
} else {
|
|
qWarning() << name << "wrong type";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found";
|
|
}
|
|
}
|
|
|
|
void ConfigParams::requestUpdate()
|
|
{
|
|
emit updateRequested();
|
|
}
|
|
|
|
void ConfigParams::requestUpdateDefault()
|
|
{
|
|
emit updateRequestDefault();
|
|
}
|
|
|
|
void ConfigParams::updateDone()
|
|
{
|
|
// Accept all names from now on again.
|
|
mUpdateOnlyName.clear();
|
|
emit updated();
|
|
}
|
|
|
|
void ConfigParams::storingDone()
|
|
{
|
|
emit stored();
|
|
}
|
|
|
|
// http://realtimecollisiondetection.net/blog/?p=89
|
|
bool ConfigParams::almostEqual(float A, float B, float eps)
|
|
{
|
|
return fabsf(A - B) <= eps * fmaxf(1.0f, fmaxf(fabsf(A), fabsf(B)));
|
|
}
|
|
|
|
QStringList ConfigParams::getSerializeOrder() const
|
|
{
|
|
return mSerializeOrder;
|
|
}
|
|
|
|
void ConfigParams::setSerializeOrder(const QStringList &serializeOrder)
|
|
{
|
|
mSerializeOrder = serializeOrder;
|
|
}
|
|
|
|
void ConfigParams::clearSerializeOrder()
|
|
{
|
|
mSerializeOrder.clear();
|
|
}
|
|
|
|
void ConfigParams::serialize(VByteArray &vb)
|
|
{
|
|
for (int i = 0;i < mSerializeOrder.size();i++) {
|
|
getParamSerial(vb, mSerializeOrder.at(i));
|
|
}
|
|
}
|
|
|
|
void ConfigParams::deSerialize(VByteArray &vb)
|
|
{
|
|
for (int i = 0;i < mSerializeOrder.size();i++) {
|
|
setParamSerial(vb, mSerializeOrder.at(i));
|
|
}
|
|
}
|
|
|
|
void ConfigParams::getXML(QXmlStreamWriter &stream, QString configName)
|
|
{
|
|
stream.writeStartDocument();
|
|
stream.writeStartElement(configName);
|
|
|
|
QHashIterator<QString, ConfigParam> i(mParams);
|
|
while (i.hasNext()) {
|
|
i.next();
|
|
|
|
const ConfigParam &p = i.value();
|
|
QString name = i.key();
|
|
|
|
switch (p.type) {
|
|
case CFG_T_BOOL:
|
|
case CFG_T_ENUM:
|
|
case CFG_T_INT:
|
|
stream.writeTextElement(name, QString::number(p.valInt));
|
|
break;
|
|
|
|
case CFG_T_DOUBLE:
|
|
stream.writeTextElement(name, QString::number(p.valDouble));
|
|
break;
|
|
|
|
case CFG_T_QSTRING:
|
|
stream.writeTextElement(name, p.valString);
|
|
break;
|
|
|
|
case CFG_T_UNDEFINED:
|
|
// Undefined parameters have no value to save.
|
|
break;
|
|
|
|
default:
|
|
qWarning() << name << ": type not supported.";
|
|
break;
|
|
}
|
|
}
|
|
|
|
stream.writeEndDocument();
|
|
}
|
|
|
|
bool ConfigParams::setXML(QXmlStreamReader &stream, QString configName)
|
|
{
|
|
bool nameFound = false;
|
|
while (stream.readNextStartElement()) {
|
|
if (stream.name() == configName) {
|
|
nameFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nameFound) {
|
|
while (stream.readNextStartElement()) {
|
|
QString name = stream.name().toString();
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
QString text = stream.readElementText();
|
|
int valInt = text.toInt();
|
|
double valDouble = text.toDouble();
|
|
|
|
switch (p.type) {
|
|
case CFG_T_BOOL:
|
|
if (valInt != p.valInt) {
|
|
p.valInt = valInt;
|
|
emit paramChangedBool(0, name, valInt);
|
|
}
|
|
break;
|
|
|
|
case CFG_T_ENUM:
|
|
if (valInt != p.valInt) {
|
|
p.valInt = valInt;
|
|
emit paramChangedEnum(0, name, valInt);
|
|
}
|
|
break;
|
|
|
|
case CFG_T_INT:
|
|
if (valInt != p.valInt) {
|
|
p.valInt = valInt;
|
|
emit paramChangedInt(0, name, valInt);
|
|
}
|
|
break;
|
|
|
|
case CFG_T_DOUBLE:
|
|
if (valDouble != p.valDouble) {
|
|
p.valDouble = valDouble;
|
|
emit paramChangedDouble(0, name, valDouble);
|
|
}
|
|
break;
|
|
|
|
case CFG_T_QSTRING:
|
|
if (text != p.valString) {
|
|
p.valString = text;
|
|
emit paramChangedQString(0, name, text);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
qWarning() << name << ": type not supported.";
|
|
break;
|
|
}
|
|
} else {
|
|
qWarning() << "Parameter not found: " << name;
|
|
stream.skipCurrentElement();
|
|
}
|
|
|
|
if (stream.hasError()) {
|
|
qWarning() << "XML ERROR :" << stream.errorString();
|
|
qWarning() << stream.lineNumber() << stream.columnNumber();
|
|
}
|
|
}
|
|
|
|
mXmlStatus = tr("OK");
|
|
emit updated();
|
|
return true;
|
|
} else {
|
|
mXmlStatus = tr("tag <b>%1</b> not found").arg(configName);
|
|
qWarning() << mXmlStatus;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ConfigParams::saveXml(QString fileName, QString configName)
|
|
{
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly)) {
|
|
mXmlStatus = tr("Could not open %1 for writing").arg(fileName);
|
|
qWarning() << mXmlStatus;
|
|
return false;
|
|
}
|
|
|
|
emit savingXml();
|
|
|
|
QXmlStreamWriter stream(&file);
|
|
stream.setCodec("UTF-8");
|
|
stream.setAutoFormatting(true);
|
|
getXML(stream, configName);
|
|
|
|
file.close();
|
|
|
|
mXmlStatus = tr("OK");
|
|
return true;
|
|
}
|
|
|
|
bool ConfigParams::loadXml(QString fileName, QString configName)
|
|
{
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::ReadOnly)) {
|
|
mXmlStatus = tr("Could not open %1 for reading").arg(fileName);
|
|
qWarning() << mXmlStatus;
|
|
return false;
|
|
}
|
|
|
|
QXmlStreamReader stream(&file);
|
|
bool res = setXML(stream, configName);
|
|
file.close();
|
|
|
|
return res;
|
|
}
|
|
|
|
QString ConfigParams::xmlStatus()
|
|
{
|
|
return mXmlStatus;
|
|
}
|
|
|
|
void ConfigParams::getParamsXML(QXmlStreamWriter &stream)
|
|
{
|
|
stream.writeStartDocument();
|
|
stream.writeStartElement("ConfigParams");
|
|
stream.writeStartElement("Params");
|
|
|
|
for (int i = 0;i < mParamList.size();i++) {
|
|
QString paramName = mParamList.at(i);
|
|
ConfigParam *p = getParam(paramName);
|
|
|
|
stream.writeStartElement(paramName);
|
|
|
|
stream.writeTextElement("longName", p->longName);
|
|
stream.writeTextElement("type", QString::number(p->type));
|
|
stream.writeTextElement("transmittable", QString::number(p->transmittable));
|
|
stream.writeTextElement("description", p->description);
|
|
stream.writeTextElement("cDefine", p->cDefine);
|
|
|
|
switch (p->type) {
|
|
case CFG_T_DOUBLE:
|
|
stream.writeTextElement("editorDecimalsDouble", QString::number(p->editorDecimalsDouble));
|
|
stream.writeTextElement("editorScale", QString::number(p->editorScale));
|
|
stream.writeTextElement("editAsPercentage", QString::number(p->editAsPercentage));
|
|
stream.writeTextElement("maxDouble", QString::number(p->maxDouble));
|
|
stream.writeTextElement("minDouble", QString::number(p->minDouble));
|
|
stream.writeTextElement("showDisplay", QString::number(p->showDisplay));
|
|
stream.writeTextElement("stepDouble", QString::number(p->stepDouble));
|
|
stream.writeTextElement("valDouble", QString::number(p->valDouble));
|
|
stream.writeTextElement("vTxDoubleScale", QString::number(p->vTxDoubleScale));
|
|
stream.writeTextElement("suffix", p->suffix);
|
|
stream.writeTextElement("vTx", QString::number(p->vTx));
|
|
break;
|
|
|
|
case CFG_T_INT:
|
|
stream.writeTextElement("editorScale", QString::number(p->editorScale));
|
|
stream.writeTextElement("editAsPercentage", QString::number(p->editAsPercentage));
|
|
stream.writeTextElement("maxInt", QString::number(p->maxInt));
|
|
stream.writeTextElement("minInt", QString::number(p->minInt));
|
|
stream.writeTextElement("showDisplay", QString::number(p->showDisplay));
|
|
stream.writeTextElement("stepInt", QString::number(p->stepInt));
|
|
stream.writeTextElement("valInt", QString::number(p->valInt));
|
|
stream.writeTextElement("suffix", p->suffix);
|
|
stream.writeTextElement("vTx", QString::number(p->vTx));
|
|
break;
|
|
|
|
case CFG_T_QSTRING:
|
|
stream.writeTextElement("valString", p->valString);
|
|
break;
|
|
|
|
case CFG_T_ENUM:
|
|
stream.writeTextElement("valInt", QString::number(p->valInt));
|
|
for (int j = 0;j < p->enumNames.size();j++) {
|
|
stream.writeTextElement("enumNames", p->enumNames.at(j));
|
|
}
|
|
break;
|
|
|
|
case CFG_T_BOOL:
|
|
stream.writeTextElement("valInt", QString::number(p->valInt));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
stream.writeEndElement();
|
|
}
|
|
|
|
stream.writeEndElement();
|
|
|
|
stream.writeStartElement("SerOrder");
|
|
for (int i = 0;i < mSerializeOrder.size();i++) {
|
|
stream.writeTextElement("ser", mSerializeOrder.at(i));
|
|
}
|
|
|
|
stream.writeEndDocument();
|
|
}
|
|
|
|
bool ConfigParams::setParamsXML(QXmlStreamReader &stream)
|
|
{
|
|
QString configName = "ConfigParams";
|
|
|
|
bool nameFound = false;
|
|
while (stream.readNextStartElement()) {
|
|
if (stream.name() == configName) {
|
|
nameFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nameFound) {
|
|
while (stream.readNextStartElement()) {
|
|
QString nameFirst = stream.name().toString();
|
|
|
|
if (nameFirst == "Params") {
|
|
clearParams();
|
|
|
|
while (stream.readNextStartElement()) {
|
|
QString paramName = stream.name().toString();
|
|
ConfigParam p;
|
|
|
|
while (stream.readNextStartElement()) {
|
|
QString name = stream.name().toString();
|
|
|
|
if (name == "description") {
|
|
p.description = stream.readElementText();
|
|
} else if (name == "cDefine") {
|
|
p.cDefine = stream.readElementText();
|
|
} else if (name == "editorDecimalsDouble") {
|
|
p.editorDecimalsDouble = stream.readElementText().toDouble();
|
|
} else if (name == "editorScale") {
|
|
p.editorScale = stream.readElementText().toDouble();
|
|
} else if (name == "editAsPercentage") {
|
|
p.editAsPercentage = stream.readElementText().toInt();
|
|
} else if (name == "enumNames") {
|
|
p.enumNames.append(stream.readElementText());
|
|
} else if (name == "longName") {
|
|
p.longName = stream.readElementText();
|
|
} else if (name == "maxDouble") {
|
|
p.maxDouble = stream.readElementText().toDouble();
|
|
} else if (name == "maxInt") {
|
|
p.maxInt = stream.readElementText().toInt();
|
|
} else if (name == "minDouble") {
|
|
p.minDouble = stream.readElementText().toDouble();
|
|
} else if (name == "minInt") {
|
|
p.minInt = stream.readElementText().toInt();
|
|
} else if (name == "showDisplay") {
|
|
p.showDisplay = stream.readElementText().toInt();
|
|
} else if (name == "stepDouble") {
|
|
p.stepDouble = stream.readElementText().toDouble();
|
|
} else if (name == "stepInt") {
|
|
p.stepInt = stream.readElementText().toInt();
|
|
} else if (name == "suffix") {
|
|
p.suffix = stream.readElementText();
|
|
} else if (name == "type") {
|
|
p.type = (CFG_T)stream.readElementText().toInt();
|
|
} else if (name == "transmittable") {
|
|
p.transmittable = stream.readElementText().toInt();
|
|
} else if (name == "valDouble") {
|
|
p.valDouble = stream.readElementText().toDouble();
|
|
} else if (name == "valInt") {
|
|
p.valInt = stream.readElementText().toInt();
|
|
} else if (name == "valString") {
|
|
p.valString = stream.readElementText();
|
|
} else if (name == "vTx") {
|
|
p.vTx = (VESC_TX_T)stream.readElementText().toInt();
|
|
} else if (name == "vTxDoubleScale") {
|
|
p.vTxDoubleScale = stream.readElementText().toDouble();
|
|
} else {
|
|
qWarning() << "Parameter not found: " << name;
|
|
stream.skipCurrentElement();
|
|
}
|
|
|
|
if (stream.hasError()) {
|
|
qWarning() << "XML ERROR :" << stream.errorString();
|
|
qWarning() << stream.lineNumber() << stream.columnNumber();
|
|
}
|
|
}
|
|
|
|
addParam(paramName, p);
|
|
}
|
|
} else if (nameFirst == "SerOrder") {
|
|
mSerializeOrder.clear();
|
|
while (stream.readNextStartElement()) {
|
|
QString name = stream.name().toString();
|
|
|
|
if (name == "ser") {
|
|
mSerializeOrder.append(stream.readElementText());
|
|
} else {
|
|
qWarning() << "Parameter not found: " << name;
|
|
stream.skipCurrentElement();
|
|
}
|
|
}
|
|
} else {
|
|
qWarning() << "Parameter not found: " << nameFirst;
|
|
stream.skipCurrentElement();
|
|
}
|
|
}
|
|
|
|
mXmlStatus = tr("OK");
|
|
return true;
|
|
} else {
|
|
mXmlStatus = tr("tag <b>%1</b> not found").arg(configName);
|
|
qWarning() << mXmlStatus;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ConfigParams::saveParamsXml(QString fileName)
|
|
{
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly)) {
|
|
mXmlStatus = tr("Could not open %1 for writing").arg(fileName);
|
|
qWarning() << mXmlStatus;
|
|
return false;
|
|
}
|
|
|
|
QXmlStreamWriter stream(&file);
|
|
stream.setCodec("UTF-8");
|
|
stream.setAutoFormatting(true);
|
|
|
|
getParamsXML(stream);
|
|
|
|
file.close();
|
|
|
|
mXmlStatus = tr("OK");
|
|
return true;
|
|
}
|
|
|
|
bool ConfigParams::loadParamsXml(QString fileName)
|
|
{
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::ReadOnly)) {
|
|
mXmlStatus = tr("Could not open %1 for reading").arg(fileName);
|
|
qWarning() << mXmlStatus;
|
|
return false;
|
|
}
|
|
|
|
QXmlStreamReader stream(&file);
|
|
bool res = setParamsXML(stream);
|
|
|
|
file.close();
|
|
|
|
return res;
|
|
}
|
|
|
|
bool ConfigParams::saveCDefines(const QString &fileName, bool wrapIfdef)
|
|
{
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::WriteOnly)) {
|
|
mXmlStatus = tr("Could not open %1 for writing").arg(fileName);
|
|
qWarning() << mXmlStatus;
|
|
return false;
|
|
}
|
|
|
|
QTextStream out(&file);
|
|
QFileInfo info(file);
|
|
QString nameStr = info.fileName().toUpper().replace(".", "_") + "_";
|
|
|
|
out << "// This file is autogenerated by EBMS Tool\n\n";
|
|
|
|
out << "#ifndef " + nameStr + "\n";
|
|
out << "#define " + nameStr + "\n\n";
|
|
|
|
for (int i = 0;i < mSerializeOrder.size();i++) {
|
|
QString name = mSerializeOrder.at(i);
|
|
|
|
if (mParams.contains(name)) {
|
|
ConfigParam &p = mParams[name];
|
|
|
|
if (!p.cDefine.isEmpty()) {
|
|
out << "// " + p.longName + "\n";
|
|
if (wrapIfdef) {
|
|
out << "#ifndef " + p.cDefine + "\n";
|
|
}
|
|
|
|
switch (p.type) {
|
|
case CFG_T_BOOL:
|
|
case CFG_T_ENUM:
|
|
case CFG_T_INT:
|
|
out << "#define " + p.cDefine + " " + QString::number(p.valInt) + "\n";
|
|
break;
|
|
|
|
case CFG_T_DOUBLE:
|
|
out << "#define " + p.cDefine + " " + QString::number(p.valDouble) + "\n";
|
|
break;
|
|
|
|
case CFG_T_QSTRING:
|
|
out << "#define " + p.cDefine + " " + p.valString + "\n";
|
|
break;
|
|
|
|
default:
|
|
qWarning() << name << ": type not supported.";
|
|
break;
|
|
}
|
|
|
|
if (wrapIfdef) {
|
|
out << "#endif\n";
|
|
}
|
|
|
|
out << "\n";
|
|
}
|
|
} else {
|
|
qWarning() << name << "not found.";
|
|
}
|
|
}
|
|
|
|
out << "// " + nameStr + "\n";
|
|
out << "#endif\n\n";
|
|
|
|
out.flush();
|
|
file.close();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief ConfigParams::checkDifference
|
|
* Check which parameters differ between this configuration and another one.
|
|
*
|
|
* @param config
|
|
* The configuration to check against.
|
|
*
|
|
* @return
|
|
* A list with parameters that differ.
|
|
*/
|
|
QStringList ConfigParams::checkDifference(ConfigParams *config)
|
|
{
|
|
QStringList res;
|
|
|
|
for(QString p: mParamList) {
|
|
ConfigParam *thisParam = this->getParam(p);
|
|
ConfigParam *otherParam = config->getParam(p);
|
|
|
|
if (thisParam && otherParam) {
|
|
if (thisParam->type == otherParam->type) {
|
|
switch (thisParam->type) {
|
|
case CFG_T_BOOL:
|
|
case CFG_T_ENUM:
|
|
case CFG_T_INT:
|
|
if (thisParam->valInt != otherParam->valInt) {
|
|
res.append(p);
|
|
}
|
|
break;
|
|
|
|
case CFG_T_DOUBLE:
|
|
if (!almostEqual(thisParam->valDouble, otherParam->valDouble, 0.0001)) {
|
|
res.append(p);
|
|
}
|
|
break;
|
|
|
|
case CFG_T_QSTRING:
|
|
if (thisParam->valString != otherParam->valString) {
|
|
res.append(p);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
ConfigParams &ConfigParams::operator=(const ConfigParams &other)
|
|
{
|
|
this->mParams = other.mParams;
|
|
this->mParamList = other.mParamList;
|
|
this->mUpdateOnlyName = other.mUpdateOnlyName;
|
|
this->mUpdatesEnabled = other.mUpdatesEnabled;
|
|
this->mSerializeOrder = other.mSerializeOrder;
|
|
this->mXmlStatus = other.mXmlStatus;
|
|
|
|
return *this;
|
|
}
|