1
0
mirror of https://bitbucket.org/librepilot/librepilot.git synced 2024-12-14 21:23:52 +01:00
LibrePilot/ground/openpilotgcs/src/plugins/coreplugin/uavconfiginfo.cpp

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();
}
/**
* @}
* @}
*/