uavconfiginfo.cpp

Go to the documentation of this file.

/*
 * 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, see <http://www.gnu.org/licenses/>
 */
#include "uavconfiginfo.h"
#include "icore.h"
#include <QMainWindow>
#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(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()));
    msgBox.setInformativeText(tr("Do you want to continue the import?"));
    msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);

    int result = 0;

    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: ")
                       + QString::number(compat));
    }
    if (result == QMessageBox::Ok)
        return false;
    else
        return true;
}

void UAVConfigInfo::notify(QString message)
{
    QMessageBox msgBox(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()));
    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();
}