mirror of
https://bitbucket.org/librepilot/librepilot.git
synced 2024-12-14 21:23:52 +01:00
295 lines
8.9 KiB
C++
295 lines
8.9 KiB
C++
/**
|
|
******************************************************************************
|
|
*
|
|
* @file uavconfiginfo.cpp
|
|
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
|
|
* @addtogroup GCSPlugins GCS Plugins
|
|
* @{
|
|
* @addtogroup CorePlugin Core Plugin
|
|
* @{
|
|
* @brief The Core GCS plugin
|
|
*****************************************************************************/
|
|
/*
|
|
* 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; either 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
|
|
* for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
/*!
|
|
\class Core::UAVConfigInfo
|
|
\mainclass
|
|
|
|
\brief The Config Info is a helper-class to handle version changes in GCS
|
|
configuration files.
|
|
|
|
The UAVConfigInfo provides version-information for the configuration-data
|
|
and callback functions to ask the user how to handle incompatble
|
|
(old or newer) configurations.
|
|
|
|
When the config is created from a \l{QSettings} instance, an UAVConfigInfo
|
|
object is passed to the factory-method. With the version-data it can decide whether
|
|
the presented config-data is compatible to the current implementation. It may
|
|
migrate old data to the current format or abort the import.
|
|
|
|
When the config is written to the \l{QSettings} instance, an UAVConfigInfo object
|
|
is passed to the writer-function. The version of the config-format should
|
|
be written to the UAVConfigInfo object. This version will be passed to
|
|
factory-method when creating the config-object from this configuration.
|
|
|
|
|
|
Typically a plugin can handle version-changes like this:
|
|
\code
|
|
MyGadgetConfiguration::MyGadgetConfiguration(QString classId, QSettings* qSettings, UAVConfigInfo *configInfo, QObject *parent) :
|
|
IUAVGadgetConfiguration(classId, parent)
|
|
{
|
|
if ( ! qSettings )
|
|
return;
|
|
|
|
if ( configInfo->version() == UAVConfigVersion() )
|
|
configInfo->setVersion("1.0.0");
|
|
|
|
if ( !configInfo->standardVersionHandlingOK(CURRENT_VERSION))
|
|
return;
|
|
|
|
... read the config ...
|
|
}
|
|
|
|
void MyGadgetConfiguration::saveConfig(QSettings* qSettings, Core::UAVConfigInfo *configInfo) const {
|
|
|
|
configInfo->setVersion(CURRENT_VERSION);
|
|
|
|
... write the config ...
|
|
}
|
|
|
|
\endcode
|
|
|
|
|
|
\section1 Version Conventions
|
|
|
|
The Version numbers are in the form "major.minor.patch" (e.g. "3.1.4") with the
|
|
following meaning:
|
|
\list
|
|
\o major: Differences in this number indicate completely incompatible formats. The
|
|
config can't be imported.
|
|
\o minor: Differences in this number indicate backwards compatible formats. Old
|
|
configs can be imported or will be automatically migrated by the new program
|
|
but configs written by this plugin can't be reasonably read by old versions of
|
|
the plugin.
|
|
\o patch: Differences in this number indicate backwards and forward compatible formats.
|
|
Configs written by this plugin can be read by old versions of the plugin. Old configs
|
|
are extended by defaults by the new plugin.
|
|
\endlist
|
|
|
|
All parts (major, minor, patch) must be numeric values.
|
|
|
|
\section1 Utility Functions
|
|
|
|
\fn bool UAVConfigInfo::standardVersionHandlingOK(UAVConfigVersion programVersion)
|
|
\brief Default version handling.
|
|
|
|
With this function the plugin can test compatiblility of the current version
|
|
with the imported version. If there are differences, the user is asked whether
|
|
he or she wants to import the settings or abort the import.
|
|
|
|
Returns true when the import should be done, false otherwise.
|
|
|
|
*/
|
|
|
|
#include "uavconfiginfo.h"
|
|
#include <QMessageBox>
|
|
|
|
#define VERSION_DEFAULT "0.0.0"
|
|
|
|
#define TEXT_MINOR_LOSS_OF_CONFIGURATION \
|
|
tr( \
|
|
" Some of the configured features might not be supported \
|
|
by your version of the plugin. You might want to upgrade the plugin.")
|
|
|
|
#define TEXT_MISSING_CONFIGURATION \
|
|
tr( \
|
|
" Some configuration is missing in the imported config and will be replaced \
|
|
by default settings.")
|
|
|
|
#define TEXT_MAJOR_LOSS_OF_CONFIGURATION \
|
|
tr( \
|
|
" Major features can't be imported \
|
|
by your version of the plugin. You should upgrade the plugin to import these settings.")
|
|
|
|
#define TEXT_NOT_COMPATIBLE \
|
|
tr( \
|
|
" The imported settings are not compatible with this plugin and won't be imported!")
|
|
|
|
using namespace Core;
|
|
|
|
UAVConfigInfo::UAVConfigInfo(QObject *parent) :
|
|
QObject(parent),
|
|
m_version(VERSION_DEFAULT),
|
|
m_locked(false),
|
|
m_nameOfConfigurable("")
|
|
{}
|
|
|
|
UAVConfigInfo::UAVConfigInfo(QSettings *qs, QObject *parent) :
|
|
QObject(parent),
|
|
m_version(VERSION_DEFAULT)
|
|
{
|
|
read(qs);
|
|
}
|
|
|
|
UAVConfigInfo::UAVConfigInfo(UAVConfigVersion version, QString nameOfConfigurable, QObject *parent) :
|
|
QObject(parent),
|
|
m_version(version),
|
|
m_locked(false),
|
|
m_nameOfConfigurable(nameOfConfigurable)
|
|
{}
|
|
|
|
UAVConfigInfo::UAVConfigInfo(IUAVGadgetConfiguration *config, QObject *parent) :
|
|
QObject(parent)
|
|
{
|
|
m_locked = config->locked();
|
|
m_nameOfConfigurable = config->classId() + "-" + config->name();
|
|
}
|
|
|
|
void UAVConfigInfo::save(QSettings *qs)
|
|
{
|
|
qs->beginGroup("configInfo");
|
|
qs->setValue("version", m_version.toString());
|
|
qs->setValue("locked", m_locked);
|
|
qs->endGroup();
|
|
}
|
|
|
|
void UAVConfigInfo::read(QSettings *qs)
|
|
{
|
|
qs->beginGroup("configInfo");
|
|
m_version = UAVConfigVersion(qs->value("version", VERSION_DEFAULT).toString());
|
|
m_locked = qs->value("locked", false).toBool();
|
|
qs->endGroup();
|
|
}
|
|
|
|
bool UAVConfigInfo::askToAbort(int compat, QString message)
|
|
{
|
|
QMessageBox msgBox;
|
|
|
|
msgBox.setInformativeText(tr("Do you want to continue the import?"));
|
|
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
|
|
|
|
int result;
|
|
|
|
switch (compat) {
|
|
case FullyCompatible:
|
|
return false;
|
|
|
|
case MinorLossOfConfiguration:
|
|
msgBox.setText(tr("INFO: ") + message + TEXT_MINOR_LOSS_OF_CONFIGURATION);
|
|
msgBox.setDefaultButton(QMessageBox::Ok);
|
|
result = msgBox.exec();
|
|
break;
|
|
|
|
case MissingConfiguration:
|
|
msgBox.setText(tr("WARNING: ") + message + TEXT_MISSING_CONFIGURATION);
|
|
msgBox.setDefaultButton(QMessageBox::Ok);
|
|
result = msgBox.exec();
|
|
break;
|
|
|
|
case MajorLossOfConfiguration:
|
|
msgBox.setText(tr("ERROR: ") + message + TEXT_MAJOR_LOSS_OF_CONFIGURATION);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
result = msgBox.exec();
|
|
break;
|
|
|
|
case NotCompatible:
|
|
msgBox.setText("ERROR: " + message + TEXT_NOT_COMPATIBLE);
|
|
msgBox.setInformativeText(tr(""));
|
|
msgBox.setStandardButtons(QMessageBox::Ok);
|
|
msgBox.exec();
|
|
return true;
|
|
|
|
default:
|
|
msgBox.setText("INTERNAL ERROR: " + message + tr("Unknown compatibility level: " + compat));
|
|
}
|
|
if (result == QMessageBox::Ok) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void UAVConfigInfo::notify(QString message)
|
|
{
|
|
QMessageBox msgBox;
|
|
|
|
msgBox.setText(message);
|
|
msgBox.exec();
|
|
}
|
|
|
|
int UAVConfigInfo::checkCompatibilityWith(UAVConfigVersion programVersion)
|
|
{
|
|
if (m_version.majorNr != programVersion.majorNr) {
|
|
return NotCompatible;
|
|
}
|
|
if (m_version.minorNr < programVersion.minorNr) {
|
|
return MissingConfiguration;
|
|
}
|
|
if (m_version.minorNr > programVersion.minorNr) {
|
|
return MajorLossOfConfiguration;
|
|
}
|
|
if (m_version.patchNr > programVersion.patchNr) {
|
|
return MinorLossOfConfiguration;
|
|
}
|
|
|
|
return FullyCompatible;
|
|
}
|
|
|
|
bool UAVConfigInfo::standardVersionHandlingOK(UAVConfigVersion programVersion)
|
|
{
|
|
return !askToAbort(
|
|
checkCompatibilityWith(programVersion),
|
|
"(" + m_nameOfConfigurable + ")");
|
|
}
|
|
|
|
UAVConfigVersion::UAVConfigVersion(int majorNum, int minorNum, int patchNum)
|
|
: majorNr(majorNum)
|
|
, minorNr(minorNum)
|
|
, patchNr(patchNum)
|
|
{}
|
|
|
|
UAVConfigVersion::UAVConfigVersion(QString versionString)
|
|
{
|
|
int begin;
|
|
int end = 0;
|
|
|
|
begin = end;
|
|
end = versionString.indexOf(".", begin);
|
|
majorNr = versionString.mid(begin, end - begin).toInt();
|
|
|
|
begin = end + 1;
|
|
end = versionString.indexOf(".", begin);
|
|
minorNr = versionString.mid(begin, end - begin).toInt();
|
|
|
|
begin = end + 1;
|
|
patchNr = versionString.mid(begin).toInt();
|
|
}
|
|
|
|
QString UAVConfigVersion::toString() const
|
|
{
|
|
return QString("%1.%2.%3").arg(majorNr).arg(minorNr).arg(patchNr);
|
|
}
|
|
|
|
bool UAVConfigVersion::operator==(const UAVConfigVersion &other)
|
|
{
|
|
return toString() == other.toString();
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
* @}
|
|
*/
|