rooty/LibrePilot
1
0
Fork 0
mirror of https://bitbucket.org/librepilot/librepilot.git synced 2024-11-29 07:24:13 +01:00
Code Issues Releases Activity

Merged in filnet/librepilot/LP-419_avoid_gcs_config_reset (pull request #457)

Browse Source 
LP-419 avoid gcs config reset

Approved-by: Philippe Renon <philippe_renon@yahoo.fr>
Approved-by: Lalanne Laurent <f5soh@free.fr>
Approved-by: Jan NIJS <dr.oblivium@gmail.com>
Approved-by: Brian Webb <webbbn@gmail.com>
This commit is contained in:
Philippe Renon 2017-09-11 20:56:23 +00:00 committed by Lalanne Laurent
commit e3a658d153
141 changed files with 2144 additions and 3411 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
ground/gcs/src/app/main.cpp
View File

@ -2,7 +2,7 @@
******************************************************************************
*
* @file main.cpp
* @author The LibrePilot Team http://www.librepilot.org Copyright (C) 2015.
* @author The LibrePilot Team http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
@ -82,17 +82,16 @@
*/
#include "qtsingleapplication.h"
#include "utils/xmlconfig.h"
#include "utils/pathutils.h"
#include "utils/filelogger.h"
#include "gcssplashscreen.h"
#include "utils/pathutils.h"
#include "utils/settingsutils.h"
#include "utils/filelogger.h"
#include <extensionsystem/pluginmanager.h>
#include <extensionsystem/pluginspec.h>
#include <extensionsystem/iplugin.h>
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/QElapsedTimer>
#include <QtCore/QTextStream>
#include <QtCore/QFileInfo>
@ -101,12 +100,9 @@
#include <QtCore/QLibraryInfo>
#include <QtCore/QTranslator>
#include <QtCore/QSettings>
#include <QtCore/QVariant>
#include <QMessageBox>
#include <QtWidgets/QApplication>
#include <QMainWindow>
#include <QSplashScreen>
#include <QApplication>
#include <QSurfaceFormat>
typedef QList<ExtensionSystem::PluginSpec *> PluginSpecSet;
@ -350,78 +346,6 @@ AppOptionValues parseCommandLine(SharedTools::QtSingleApplication &app,
return appOptionValues;
}
void loadFactoryDefaults(QSettings &settings, AppOptionValues &appOptionValues)
{
QDir directory(Utils::GetDataPath() + QString("configurations"));
qDebug() << "Looking for factory defaults configuration files in:" << directory.absolutePath();
QString fileName;
// check if command line option -config-file contains a file name
QString commandLine = appOptionValues.value(CONFIG_FILE_OPTION);
if (!commandLine.isEmpty()) {
QFileInfo fi(commandLine);
if (fi.isRelative()) {
// file name specified on command line has a relative path
commandLine = directory.absolutePath() + QDir::separator() + commandLine;
}
if (QFile::exists(commandLine)) {
fileName = commandLine;
qDebug() << "Configuration file" << fileName << "specified on command line will be loaded.";
} else {
qWarning() << "Configuration file" << commandLine << "specified on command line does not exist.";
}
}
if (fileName.isEmpty()) {
// check default file
if (QFile::exists(directory.absolutePath() + QDir::separator() + DEFAULT_CONFIG_FILENAME)) {
// use default file name
fileName = directory.absolutePath() + QDir::separator() + DEFAULT_CONFIG_FILENAME;
qDebug() << "Default configuration file" << fileName << "will be loaded.";
} else {
qWarning() << "No default configuration file found in" << directory.absolutePath();
}
}
if (fileName.isEmpty()) {
// TODO should we exit violently?
qCritical() << "No default configuration file found!";
return;
}
// create settings from file
QSettings qs(fileName, XmlConfig::XmlSettingsFormat);
// transfer loaded settings to application settings
QStringList keys = qs.allKeys();
foreach(QString key, keys) {
settings.setValue(key, qs.value(key));
}
qDebug() << "Configuration file" << fileName << "was loaded.";
}
void overrideSettings(QSettings &settings, const QStringList &arguments)
{
// Options like -D My/setting=test
QRegExp rx("([^=]+)=(.*)");
for (int i = 0; i < arguments.size(); ++i) {
if (CONFIG_OPTION == arguments[i]) {
if (rx.indexIn(arguments[++i]) > -1) {
QString key = rx.cap(1);
QString value = rx.cap(2);
qDebug() << "User setting" << key << "set to value" << value;
settings.setValue(key, value);
}
}
}
settings.sync();
}
void loadTranslators(QString language, QTranslator &translator, QTranslator &qtTranslator)
{
const QString &creatorTrPath = Utils::GetDataPath() + QLatin1String("translations");
@ -454,7 +378,6 @@ int runApplication(int argc, char * *argv)
QCoreApplication::setApplicationName(APP_NAME);
QCoreApplication::setOrganizationName(ORG_NAME);
QSettings::setDefaultFormat(XmlConfig::XmlSettingsFormat);
// initialize the plugin manager
ExtensionSystem::PluginManager pluginManager;
@ -462,7 +385,7 @@ int runApplication(int argc, char * *argv)
pluginManager.setPluginPaths(Utils::GetPluginPaths());
// parse command line
qDebug() << "Command line" << app.arguments();
qDebug() << "main - command line" << app.arguments();
QString errorMessage;
AppOptionValues appOptionValues = parseCommandLine(app, pluginManager, errorMessage);
if (!errorMessage.isEmpty()) {
@ -473,39 +396,32 @@ int runApplication(int argc, char * *argv)
return -1;
}
// start logging to file if requested
if (appOptionValues.contains(LOG_FILE_OPTION)) {
QString logFileName = appOptionValues.value(LOG_FILE_OPTION);
logInit(logFileName);
// relog command line arguments for the benefit of the file logger...
qDebug() << "Command line" << app.arguments();
qDebug() << "main - command line" << app.arguments();
}
// init settings
Utils::initSettings(appOptionValues.value(CONFIG_FILE_OPTION));
// load user settings
// Must be done before any QSettings class is created
// keep this in sync with the MainWindow ctor in coreplugin/mainwindow.cpp
QString settingsPath = Utils::GetDataPath();
qDebug() << "Loading system settings from" << settingsPath;
QSettings::setPath(XmlConfig::XmlSettingsFormat, QSettings::SystemScope, settingsPath);
QSettings settings;
qDebug() << "Loading user settings from" << settings.fileName();
qDebug() << "main - loading user settings from" << settings.fileName();
// need to reset all user settings?
if (appOptionValues.contains(RESET_OPTION)) {
qDebug() << "Resetting user settings!";
settings.clear();
}
// check if we have user settings
if (!settings.allKeys().count()) {
// no user settings, load the factory defaults
qDebug() << "No user settings found, loading factory defaults...";
loadFactoryDefaults(settings, appOptionValues);
// need to reset user settings?
if (settings.allKeys().isEmpty() || appOptionValues.contains(RESET_OPTION)) {
qDebug() << "main - resetting user settings";
Utils::resetToFactoryDefaults(settings);
}
Utils::mergeFactoryDefaults(settings);
// override settings with command line provided values
// take notice that the overridden values will be saved in the user settings and will continue to be effective
// in subsequent GCS runs
overrideSettings(settings, app.arguments());
Utils::overrideSettings(settings, argc, argv);
// initialize GCS locale
// use the value defined by the General/Locale setting or default to system Locale.
@ -559,8 +475,8 @@ int runApplication(int argc, char * *argv)
}
if (!coreplugin) {
QString nativePaths = QDir::toNativeSeparators(Utils::GetPluginPaths().join(QLatin1String(",")));
const QString reason = QCoreApplication::translate("Application", "Could not find 'Core.pluginspec' in %1").arg(
nativePaths);
const QString reason = QCoreApplication::translate("Application", "Could not find '%1.pluginspec' in %2")
.arg(CORE_PLUGIN_NAME).arg(nativePaths);
displayError(msgCoreLoadFailure(reason));
return 1;
}
@ -591,19 +507,17 @@ int runApplication(int argc, char * *argv)
return 1;
}
{
QStringList errors;
foreach(ExtensionSystem::PluginSpec * p, pluginManager.plugins()) {
if (p->hasError()) {
errors.append(p->errorString());
}
}
if (!errors.isEmpty()) {
QMessageBox::warning(0,
QCoreApplication::translate("Application", "%1 - Plugin loader messages").arg(GCS_BIG_NAME),
errors.join(QString::fromLatin1("\n\n")));
QStringList errors;
foreach(ExtensionSystem::PluginSpec * p, pluginManager.plugins()) {
if (p->hasError()) {
errors.append(p->errorString());
}
}
if (!errors.isEmpty()) {
QMessageBox::warning(0,
QCoreApplication::translate("Application", "%1 - Plugin loader messages").arg(GCS_BIG_NAME),
errors.join(QString::fromLatin1("\n\n")));
}
if (isFirstInstance) {
// Set up lock and remote arguments for the first instance only.

86
ground/gcs/src/libs/utils/abstractprocess.h
View File

@ -1,86 +0,0 @@
/**
******************************************************************************
*
* @file abstractprocess.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* 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
*/
#ifndef ABSTRACTPROCESS_H
#define ABSTRACTPROCESS_H
#include "utils_global.h"
#include <QtCore/QStringList>
namespace Utils {
class QTCREATOR_UTILS_EXPORT AbstractProcess {
public:
AbstractProcess() {}
virtual ~AbstractProcess() {}
QString workingDirectory() const
{
return m_workingDir;
}
void setWorkingDirectory(const QString &dir)
{
m_workingDir = dir;
}
QStringList environment() const
{
return m_environment;
}
void setEnvironment(const QStringList &env)
{
m_environment = env;
}
virtual bool start(const QString &program, const QStringList &args) = 0;
virtual void stop() = 0;
virtual bool isRunning() const = 0;
virtual qint64 applicationPID() const = 0;
virtual int exitCode() const = 0;
// signals:
virtual void processError(const QString &error) = 0;
#ifdef Q_OS_WIN
// Add PATH and SystemRoot environment variables in case they are missing
static QStringList fixWinEnvironment(const QStringList &env);
// Quote a Windows command line correctly for the "CreateProcess" API
static QString createWinCommandline(const QString &program, const QStringList &args);
// Create a bytearray suitable to be passed on as environment
// to the "CreateProcess" API (0-terminated UTF 16 strings).
static QByteArray createWinEnvironment(const QStringList &env);
#endif
private:
QString m_workingDir;
QStringList m_environment;
};
} // namespace Utils
#endif // ABSTRACTPROCESS_H

119
ground/gcs/src/libs/utils/abstractprocess_win.cpp
View File

@ -1,119 +0,0 @@
/**
******************************************************************************
*
* @file abstractprocess_win.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* 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
*/
#include "abstractprocess.h"
#include <windows.h>
namespace Utils {
QStringList AbstractProcess::fixWinEnvironment(const QStringList &env)
{
QStringList envStrings = env;
// add PATH if necessary (for DLL loading)
if (envStrings.filter(QRegExp(QLatin1String("^PATH="), Qt::CaseInsensitive)).isEmpty()) {
QByteArray path = qgetenv("PATH");
if (!path.isEmpty()) {
envStrings.prepend(QString(QLatin1String("PATH=%1")).arg(QString::fromLocal8Bit(path)));
}
}
// add systemroot if needed
if (envStrings.filter(QRegExp(QLatin1String("^SystemRoot="), Qt::CaseInsensitive)).isEmpty()) {
QByteArray systemRoot = qgetenv("SystemRoot");
if (!systemRoot.isEmpty()) {
envStrings.prepend(QString(QLatin1String("SystemRoot=%1")).arg(QString::fromLocal8Bit(systemRoot)));
}
}
return envStrings;
}
QString AbstractProcess::createWinCommandline(const QString &program, const QStringList &args)
{
const QChar doubleQuote = QLatin1Char('"');
const QChar blank = QLatin1Char(' ');
const QChar backSlash = QLatin1Char('\\');
QString programName = program;
if (!programName.startsWith(doubleQuote) && !programName.endsWith(doubleQuote) && programName.contains(blank)) {
programName.insert(0, doubleQuote);
programName.append(doubleQuote);
}
// add the prgram as the first arrg ... it works better
programName.replace(QLatin1Char('/'), backSlash);
QString cmdLine = programName;
if (args.empty()) {
return cmdLine;
}
cmdLine += blank;
for (int i = 0; i < args.size(); ++i) {
QString tmp = args.at(i);
// in the case of \" already being in the string the \ must also be escaped
tmp.replace(QLatin1String("\\\""), QLatin1String("\\\\\""));
// escape a single " because the arguments will be parsed
tmp.replace(QString(doubleQuote), QLatin1String("\\\""));
if (tmp.isEmpty() || tmp.contains(blank) || tmp.contains('\t')) {
// The argument must not end with a \ since this would be interpreted
// as escaping the quote -- rather put the \ behind the quote: e.g.
// rather use "foo"\ than "foo\"
QString endQuote(doubleQuote);
int i = tmp.length();
while (i > 0 && tmp.at(i - 1) == backSlash) {
--i;
endQuote += backSlash;
}
cmdLine += QLatin1String(" \"");
cmdLine += tmp.left(i);
cmdLine += endQuote;
} else {
cmdLine += blank;
cmdLine += tmp;
}
}
return cmdLine;
}
QByteArray AbstractProcess::createWinEnvironment(const QStringList &env)
{
QByteArray envlist;
int pos = 0;
foreach(const QString &tmp, env) {
const uint tmpSize = sizeof(TCHAR) * (tmp.length() + 1);
envlist.resize(envlist.size() + tmpSize);
memcpy(envlist.data() + pos, tmp.utf16(), tmpSize);
pos += tmpSize;
}
envlist.resize(envlist.size() + 2);
envlist[pos++] = 0;
envlist[pos++] = 0;
return envlist;
}
} // namespace Utils

83
ground/gcs/src/libs/utils/consoleprocess.cpp
View File

@ -1,83 +0,0 @@
/**
******************************************************************************
*
* @file consoleprocess.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* 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
*/
#include "consoleprocess.h"
namespace Utils {
QString ConsoleProcess::modeOption(Mode m)
{
switch (m) {
case Debug:
return QLatin1String("debug");
case Suspend:
return QLatin1String("suspend");
case Run:
break;
}
return QLatin1String("run");
}
QString ConsoleProcess::msgCommChannelFailed(const QString &error)
{
return tr("Cannot set up communication channel: %1").arg(error);
}
QString ConsoleProcess::msgPromptToClose()
{
// ! Showed in a terminal which might have
// ! a different character set on Windows.
return tr("Press <RETURN> to close this window...");
}
QString ConsoleProcess::msgCannotCreateTempFile(const QString &why)
{
return tr("Cannot create temporary file: %1").arg(why);
}
QString ConsoleProcess::msgCannotCreateTempDir(const QString & dir, const QString &why)
{
return tr("Cannot create temporary directory '%1': %2").arg(dir, why);
}
QString ConsoleProcess::msgUnexpectedOutput()
{
return tr("Unexpected output from helper program.");
}
QString ConsoleProcess::msgCannotChangeToWorkDir(const QString & dir, const QString &why)
{
return tr("Cannot change to working directory '%1': %2").arg(dir, why);
}
QString ConsoleProcess::msgCannotExecute(const QString & p, const QString &why)
{
return tr("Cannot execute '%1': %2").arg(p, why);
}
}

154
ground/gcs/src/libs/utils/consoleprocess.h
View File

@ -1,154 +0,0 @@
/**
******************************************************************************
*
* @file consoleprocess.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* 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
*/
#ifndef CONSOLEPROCESS_H
#define CONSOLEPROCESS_H
#include "abstractprocess.h"
#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QProcess>
#include <QtNetwork/QLocalServer>
#ifdef Q_OS_WIN
#include <windows.h>
QT_BEGIN_NAMESPACE
class QWinEventNotifier;
QT_END_NAMESPACE
#endif
QT_BEGIN_NAMESPACE
class QSettings;
class QTemporaryFile;
QT_END_NAMESPACE
namespace Utils {
class QTCREATOR_UTILS_EXPORT ConsoleProcess : public QObject, public AbstractProcess {
Q_OBJECT
public:
enum Mode { Run, Debug, Suspend };
ConsoleProcess(QObject *parent = 0);
~ConsoleProcess();
bool start(const QString &program, const QStringList &args);
void stop();
void setMode(Mode m)
{
m_mode = m;
}
Mode mode() const
{
return m_mode;
}
bool isRunning() const; // This reflects the state of the console+stub
qint64 applicationPID() const
{
return m_appPid;
}
int exitCode() const
{
return m_appCode;
} // This will be the signal number if exitStatus == CrashExit
QProcess::ExitStatus exitStatus() const
{
return m_appStatus;
}
#ifdef Q_OS_UNIX
void setSettings(QSettings *settings)
{
m_settings = settings;
}
static QString defaultTerminalEmulator();
static QString terminalEmulator(const QSettings *settings);
static void setTerminalEmulator(QSettings *settings, const QString &term);
#endif
signals:
void processError(const QString &error);
// These reflect the state of the actual client process
void processStarted();
void processStopped();
// These reflect the state of the console+stub
void wrapperStarted();
void wrapperStopped();
private slots:
void stubConnectionAvailable();
void readStubOutput();
void stubExited();
#ifdef Q_OS_WIN
void inferiorExited();
#endif
private:
static QString modeOption(Mode m);
static QString msgCommChannelFailed(const QString &error);
static QString msgPromptToClose();
static QString msgCannotCreateTempFile(const QString &why);
static QString msgCannotCreateTempDir(const QString & dir, const QString &why);
static QString msgUnexpectedOutput();
static QString msgCannotChangeToWorkDir(const QString & dir, const QString &why);
static QString msgCannotExecute(const QString & p, const QString &why);
QString stubServerListen();
void stubServerShutdown();
#ifdef Q_OS_WIN
void cleanupStub();
void cleanupInferior();
#endif
Mode m_mode;
qint64 m_appPid;
int m_appCode;
QString m_executable;
QProcess::ExitStatus m_appStatus;
QLocalServer m_stubServer;
QLocalSocket *m_stubSocket;
QTemporaryFile *m_tempFile;
#ifdef Q_OS_WIN
PROCESS_INFORMATION *m_pid;
HANDLE m_hInferior;
QWinEventNotifier *inferiorFinishedNotifier;
QWinEventNotifier *processFinishedNotifier;
#else
QProcess m_process;
QByteArray m_stubServerDir;
QSettings *m_settings;
#endif
};
} // namespace Utils
#endif // ifndef CONSOLEPROCESS_H

270
ground/gcs/src/libs/utils/consoleprocess_unix.cpp
View File

@ -1,270 +0,0 @@
/**
******************************************************************************
*
* @file consoleprocess_unix.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* 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
*/
#include "consoleprocess.h"
#include <QtCore/QCoreApplication>
#include <QtCore/QDir>
#include <QtCore/QSettings>
#include <QtCore/QTemporaryFile>
#include <QtNetwork/QLocalSocket>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
using namespace Utils;
ConsoleProcess::ConsoleProcess(QObject *parent) :
QObject(parent),
m_mode(Run),
m_appPid(0),
m_stubSocket(0),
m_settings(0)
{
connect(&m_stubServer, SIGNAL(newConnection()), SLOT(stubConnectionAvailable()));
m_process.setProcessChannelMode(QProcess::ForwardedChannels);
connect(&m_process, SIGNAL(finished(int, QProcess::ExitStatus)),
SLOT(stubExited()));
}
ConsoleProcess::~ConsoleProcess()
{
stop();
}
bool ConsoleProcess::start(const QString &program, const QStringList &args)
{
if (isRunning()) {
return false;
}
const QString err = stubServerListen();
if (!err.isEmpty()) {
emit processError(msgCommChannelFailed(err));
return false;
}
if (!environment().isEmpty()) {
m_tempFile = new QTemporaryFile();
if (!m_tempFile->open()) {
stubServerShutdown();
emit processError(msgCannotCreateTempFile(m_tempFile->errorString()));
delete m_tempFile;
m_tempFile = 0;
return false;
}
foreach(const QString &var, environment()) {
m_tempFile->write(var.toLocal8Bit());
m_tempFile->write("", 1);
}
m_tempFile->flush();
}
QStringList xtermArgs = terminalEmulator(m_settings).split(QLatin1Char(' ')); // FIXME: quoting
xtermArgs
#ifdef Q_OS_MAC
<< (QCoreApplication::applicationDirPath() + QLatin1String("/../Resources/qtcreator_process_stub"))
#else
<< (QCoreApplication::applicationDirPath() + QLatin1String("/qtcreator_process_stub"))
#endif
<< modeOption(m_mode)
<< m_stubServer.fullServerName()
<< msgPromptToClose()
<< workingDirectory()
<< (m_tempFile ? m_tempFile->fileName() : 0)
<< program << args;
QString xterm = xtermArgs.takeFirst();
m_process.start(xterm, xtermArgs);
if (!m_process.waitForStarted()) {
stubServerShutdown();
emit processError(tr("Cannot start the terminal emulator '%1'.").arg(xterm));
delete m_tempFile;
m_tempFile = 0;
return false;
}
m_executable = program;
emit wrapperStarted();
return true;
}
void ConsoleProcess::stop()
{
if (!isRunning()) {
return;
}
stubServerShutdown();
m_appPid = 0;
m_process.terminate();
if (!m_process.waitForFinished(1000)) {
m_process.kill();
}
m_process.waitForFinished();
}
bool ConsoleProcess::isRunning() const
{
return m_process.state() != QProcess::NotRunning;
}
QString ConsoleProcess::stubServerListen()
{
// We need to put the socket in a private directory, as some systems simply do not
// check the file permissions of sockets.
QString stubFifoDir;
forever {
{
QTemporaryFile tf;
if (!tf.open()) {
return msgCannotCreateTempFile(tf.errorString());
}
stubFifoDir = QFile::encodeName(tf.fileName());
}
// By now the temp file was deleted again
m_stubServerDir = QFile::encodeName(stubFifoDir);
if (!::mkdir(m_stubServerDir.constData(), 0700)) {
break;
}
if (errno != EEXIST) {
return msgCannotCreateTempDir(stubFifoDir, QString::fromLocal8Bit(strerror(errno)));
}
}
const QString stubServer = stubFifoDir + "/stub-socket";
if (!m_stubServer.listen(stubServer)) {
::rmdir(m_stubServerDir.constData());
return tr("Cannot create socket '%1': %2").arg(stubServer, m_stubServer.errorString());
}
return QString();
}
void ConsoleProcess::stubServerShutdown()
{
delete m_stubSocket;
m_stubSocket = 0;
if (m_stubServer.isListening()) {
m_stubServer.close();
::rmdir(m_stubServerDir.constData());
}
}
void ConsoleProcess::stubConnectionAvailable()
{
m_stubSocket = m_stubServer.nextPendingConnection();
connect(m_stubSocket, SIGNAL(readyRead()), SLOT(readStubOutput()));
}
static QString errorMsg(int code)
{
return QString::fromLocal8Bit(strerror(code));
}
void ConsoleProcess::readStubOutput()
{
while (m_stubSocket->canReadLine()) {
QByteArray out = m_stubSocket->readLine();
out.chop(1); // \n
if (out.startsWith("err:chdir ")) {
emit processError(msgCannotChangeToWorkDir(workingDirectory(), errorMsg(out.mid(10).toInt())));
} else if (out.startsWith("err:exec ")) {
emit processError(msgCannotExecute(m_executable, errorMsg(out.mid(9).toInt())));
} else if (out.startsWith("pid ")) {
// Will not need it any more
delete m_tempFile;
m_tempFile = 0;
m_appPid = out.mid(4).toInt();
emit processStarted();
} else if (out.startsWith("exit ")) {
m_appStatus = QProcess::NormalExit;
m_appCode = out.mid(5).toInt();
m_appPid = 0;
emit processStopped();
} else if (out.startsWith("crash ")) {
m_appStatus = QProcess::CrashExit;
m_appCode = out.mid(6).toInt();
m_appPid = 0;
emit processStopped();
} else {
emit processError(msgUnexpectedOutput());
m_process.terminate();
break;
}
}
}
void ConsoleProcess::stubExited()
{
// The stub exit might get noticed before we read the error status.
if (m_stubSocket && m_stubSocket->state() == QLocalSocket::ConnectedState) {
m_stubSocket->waitForDisconnected();
}
stubServerShutdown();
delete m_tempFile;
m_tempFile = 0;
if (m_appPid) {
m_appStatus = QProcess::CrashExit;
m_appCode = -1;
m_appPid = 0;
emit processStopped(); // Maybe it actually did not, but keep state consistent
}
emit wrapperStopped();
}
QString ConsoleProcess::defaultTerminalEmulator()
{
// FIXME: enable this once runInTerminal works nicely
#if 0 // def Q_OS_MAC
return QDir::cleanPath(QCoreApplication::applicationDirPath()
+ QLatin1String("/../Resources/runInTerminal.command"));
#else
return QLatin1String("xterm");
#endif
}
QString ConsoleProcess::terminalEmulator(const QSettings *settings)
{
const QString dflt = defaultTerminalEmulator() + QLatin1String(" -e");
if (!settings) {
return dflt;
}
return settings->value(QLatin1String("General/TerminalEmulator"), dflt).toString();
}
void ConsoleProcess::setTerminalEmulator(QSettings *settings, const QString &term)
{
return settings->setValue(QLatin1String("General/TerminalEmulator"), term);
}

265
ground/gcs/src/libs/utils/consoleprocess_win.cpp
View File

@ -1,265 +0,0 @@
/**
******************************************************************************
*
* @file consoleprocess_win.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* 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
*/
#include "consoleprocess.h"
#include "winutils.h"
#include <QtCore/QCoreApplication>
#include <QtCore/QDir>
#include <QtCore/QTemporaryFile>
#include <QtCore/QAbstractEventDispatcher>
#include "qwineventnotifier_p.h"
#include <QtNetwork/QLocalSocket>
#include <stdlib.h>
using namespace Utils;
ConsoleProcess::ConsoleProcess(QObject *parent) :
QObject(parent),
m_mode(Run),
m_appPid(0),
m_stubSocket(0),
m_tempFile(0),
m_pid(0),
m_hInferior(NULL),
inferiorFinishedNotifier(0),
processFinishedNotifier(0)
{
connect(&m_stubServer, SIGNAL(newConnection()), SLOT(stubConnectionAvailable()));
}
ConsoleProcess::~ConsoleProcess()
{
stop();
}
bool ConsoleProcess::start(const QString &program, const QStringList &args)
{
if (isRunning()) {
return false;
}
const QString err = stubServerListen();
if (!err.isEmpty()) {
emit processError(msgCommChannelFailed(err));
return false;
}
if (!environment().isEmpty()) {
m_tempFile = new QTemporaryFile();
if (!m_tempFile->open()) {
stubServerShutdown();
emit processError(msgCannotCreateTempFile(m_tempFile->errorString()));
delete m_tempFile;
m_tempFile = 0;
return false;
}
QTextStream out(m_tempFile);
out.setCodec("UTF-16LE");
out.setGenerateByteOrderMark(false);
foreach(const QString &var, fixWinEnvironment(environment()))
out << var << QChar(0);
out << QChar(0);
}
STARTUPINFO si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
m_pid = new PROCESS_INFORMATION;
ZeroMemory(m_pid, sizeof(PROCESS_INFORMATION));
QString workDir = QDir::toNativeSeparators(workingDirectory());
if (!workDir.isEmpty() && !workDir.endsWith('\\')) {
workDir.append('\\');
}
QStringList stubArgs;
stubArgs << modeOption(m_mode)
<< m_stubServer.fullServerName()
<< workDir
<< (m_tempFile ? m_tempFile->fileName() : 0)
<< createWinCommandline(program, args)
<< msgPromptToClose();
const QString cmdLine = createWinCommandline(
QCoreApplication::applicationDirPath() + QLatin1String("/qtcreator_process_stub.exe"), stubArgs);
bool success = CreateProcessW(0, (WCHAR *)cmdLine.utf16(),
0, 0, FALSE, CREATE_NEW_CONSOLE,
0, 0,
&si, m_pid);
if (!success) {
delete m_pid;
m_pid = 0;
delete m_tempFile;
m_tempFile = 0;
stubServerShutdown();
emit processError(tr("The process '%1' could not be started: %2").arg(cmdLine, winErrorMessage(GetLastError())));
return false;
}
processFinishedNotifier = new QWinEventNotifier(m_pid->hProcess, this);
connect(processFinishedNotifier, SIGNAL(activated(HANDLE)), SLOT(stubExited()));
emit wrapperStarted();
return true;
}
void ConsoleProcess::stop()
{
if (m_hInferior != NULL) {
TerminateProcess(m_hInferior, (unsigned)-1);
cleanupInferior();
}
if (m_pid) {
TerminateProcess(m_pid->hProcess, (unsigned)-1);
WaitForSingleObject(m_pid->hProcess, INFINITE);
cleanupStub();
}
}
bool ConsoleProcess::isRunning() const
{
return m_pid != 0;
}
QString ConsoleProcess::stubServerListen()
{
if (m_stubServer.listen(QString::fromLatin1("creator-%1-%2")
.arg(QCoreApplication::applicationPid())
.arg(rand()))) {
return QString();
}
return m_stubServer.errorString();
}
void ConsoleProcess::stubServerShutdown()
{
delete m_stubSocket;
m_stubSocket = 0;
if (m_stubServer.isListening()) {
m_stubServer.close();
}
}
void ConsoleProcess::stubConnectionAvailable()
{
m_stubSocket = m_stubServer.nextPendingConnection();
connect(m_stubSocket, SIGNAL(readyRead()), SLOT(readStubOutput()));
}
void ConsoleProcess::readStubOutput()
{
while (m_stubSocket->canReadLine()) {
QByteArray out = m_stubSocket->readLine();
out.chop(2); // \r\n
if (out.startsWith("err:chdir ")) {
emit processError(msgCannotChangeToWorkDir(workingDirectory(), winErrorMessage(out.mid(10).toInt())));
} else if (out.startsWith("err:exec ")) {
emit processError(msgCannotExecute(m_executable, winErrorMessage(out.mid(9).toInt())));
} else if (out.startsWith("pid ")) {
// Wil not need it any more
delete m_tempFile;
m_tempFile = 0;
m_appPid = out.mid(4).toInt();
m_hInferior = OpenProcess(
SYNCHRONIZE | PROCESS_QUERY_INFORMATION | PROCESS_TERMINATE,
FALSE, m_appPid);
if (m_hInferior == NULL) {
emit processError(tr("Cannot obtain a handle to the inferior: %1")
.arg(winErrorMessage(GetLastError())));
// Uhm, and now what?
continue;
}
inferiorFinishedNotifier = new QWinEventNotifier(m_hInferior, this);
connect(inferiorFinishedNotifier, SIGNAL(activated(HANDLE)), SLOT(inferiorExited()));
emit processStarted();
} else {
emit processError(msgUnexpectedOutput());
TerminateProcess(m_pid->hProcess, (unsigned)-1);
break;
}
}
}
void ConsoleProcess::cleanupInferior()
{
delete inferiorFinishedNotifier;
inferiorFinishedNotifier = 0;
CloseHandle(m_hInferior);
m_hInferior = NULL;
m_appPid = 0;
}
void ConsoleProcess::inferiorExited()
{
DWORD chldStatus;
if (!GetExitCodeProcess(m_hInferior, &chldStatus)) {
emit processError(tr("Cannot obtain exit status from inferior: %1")
.arg(winErrorMessage(GetLastError())));
}
cleanupInferior();
m_appStatus = QProcess::NormalExit;
m_appCode = chldStatus;
emit processStopped();
}
void ConsoleProcess::cleanupStub()
{
stubServerShutdown();
delete processFinishedNotifier;
processFinishedNotifier = 0;
CloseHandle(m_pid->hThread);
CloseHandle(m_pid->hProcess);
delete m_pid;
m_pid = 0;
delete m_tempFile;
m_tempFile = 0;
}
void ConsoleProcess::stubExited()
{
// The stub exit might get noticed before we read the pid for the kill.
if (m_stubSocket && m_stubSocket->state() == QLocalSocket::ConnectedState) {
m_stubSocket->waitForDisconnected();
}
cleanupStub();
if (m_hInferior != NULL) {
TerminateProcess(m_hInferior, (unsigned)-1);
cleanupInferior();
m_appStatus = QProcess::CrashExit;
m_appCode = -1;
emit processStopped();
}
emit wrapperStopped();
}

264
ground/gcs/src/libs/utils/settingsutils.cpp Normal file
View File

@ -0,0 +1,264 @@
/**
******************************************************************************
*
* @file settingsutils.cpp
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* @brief Settings utilities
*
* @see The GNU Public License (GPL) Version 3
*
*****************************************************************************/
/*
* 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
*/
#include "settingsutils.h"
#include "pathutils.h"
#include "xmlconfig.h"
#include <QFileInfo>
#include <QDir>
#include <QDebug>
#include <QSettings>
namespace Utils {
static const QString DEFAULT_CONFIG_DIRNAME = "configurations";
static const QString DEFAULT_CONFIG_FILENAME = "default.xml";
const QLatin1String CONFIG_OPTION("-D");
// list of read only QSettings objects containing factory defaults
QList<QSettings const *> factorySettingsList;
/*
* Helper class to manage a simple registry
* Each entry in the registry is a configuration path
* For example : UAVGadgetConfigurations/DialGadget/Attitude
* Note that entries are base64 encoded so QSettings does not mess with them
*/
class QTCREATOR_UTILS_EXPORT Registry {
public:
Registry()
{
QSettings settings;
settings.beginGroup("Registry");
registry = settings.childKeys();
settings.endGroup();
}
void save() const
{
QSettings settings;
settings.beginGroup("Registry");
settings.remove("");
foreach(QString entry, registry) {
settings.setValue(entry, 1);
}
settings.endGroup();
}
bool contains(QString &entry) const
{
return registry.contains(key(entry));
}
void add(QString &entry)
{
registry.append(key(entry));
}
private:
QStringList registry;
QString key(QString &entry) const
{
return entry.toUtf8().toBase64();
}
};
QString checkFile(QString fileName)
{
if (!fileName.isEmpty()) {
QFileInfo fi(fileName);
if (fi.isRelative()) {
// file name has a relative path
QDir directory(Utils::GetDataPath() + QString("configurations"));
fileName = directory.absoluteFilePath(fileName);
}
if (!QFile::exists(fileName)) {
qWarning() << "Configuration file" << fileName << "does not exist.";
fileName = "";
}
}
return fileName;
}
template<typename Func>
void applyToFactorySettings(Func func)
{
foreach(QSettings const *settings, factorySettingsList) {
func(*settings);
}
}
void copySettings(const QSettings &from, QSettings &to)
{
foreach(QString key, from.allKeys()) {
if (!to.contains(key)) {
// qDebug() << "++" << key << from.value(key);
to.setValue(key, from.value(key));
} else if (from.value(key) != to.value(key)) {
// qDebug() << ">>" << key << from.value(key) << to.value(key);
to.setValue(key, from.value(key));
}
}
}
void mergeSettings(Registry &registry, const QSettings &from, QSettings &to)
{
to.beginGroup(from.group());
// iterate over factory defaults groups
// note that merging could be done in smarter way
// currently we do a "all or nothing" merge but we could do something more granular
// this, would allow, new configuration options to be added to existing configurations
foreach(QString group, from.childGroups()) {
const_cast<QSettings &>(from).beginGroup(group);
to.beginGroup(group);
QString id = from.group();
if (!registry.contains(id)) {
// registry keeps growing...
registry.add(id);
// copy settings only if destination group is totally empty (see comment above)
if (to.allKeys().count() <= 0 && to.childGroups().count() <= 0) {
// found new group, copy it to the destination
qDebug() << "settings - adding new configuration" << id;
copySettings(from, to);
}
}
to.endGroup();
const_cast<QSettings &>(from).endGroup();
}
to.endGroup();
}
void mergeFactorySettings(Registry &registry, const QSettings &from, QSettings &to)
{
const_cast<QSettings &>(from).beginGroup("Plugins");
mergeSettings(registry, from, to);
const_cast<QSettings &>(from).endGroup();
const_cast<QSettings &>(from).beginGroup("UAVGadgetConfigurations");
foreach(QString childGroup, from.childGroups()) {
const_cast<QSettings &>(from).beginGroup(childGroup);
mergeSettings(registry, from, to);
const_cast<QSettings &>(from).endGroup();
}
const_cast<QSettings &>(from).endGroup();
}
void initSettings(const QString &factoryDefaultsFileName)
{
QSettings::setDefaultFormat(XmlConfig::XmlFormat);
QDir directory(Utils::GetDataPath() + DEFAULT_CONFIG_DIRNAME);
// check if command line option -config-file contains a file name
QString fileName = checkFile(factoryDefaultsFileName);
if (fileName.isEmpty()) {
// check default file
qDebug() << "settings - looking for factory defaults configuration files in" << directory.absolutePath();
fileName = checkFile(directory.absoluteFilePath(DEFAULT_CONFIG_FILENAME));
}
if (fileName.isEmpty()) {
// TODO should we exit violently?
qCritical() << "No default configuration file found!";
return;
}
QStringList files;
// common default
files << fileName;
// OS specific default
#ifdef Q_OS_MAC
files << directory.absoluteFilePath("default_macos.xml");
#elif defined(Q_OS_LINUX)
files << directory.absoluteFilePath("default_linux.xml");
#else
files << directory.absoluteFilePath("default_windows.xml");
#endif
foreach(QString file, files) {
file = checkFile(file);
if (!file.isEmpty()) {
QSettings const *settings = new QSettings(file, XmlConfig::XmlFormat);
qDebug() << "settings - loaded factory defaults" << file;
factorySettingsList.append(settings);
}
}
}
void overrideSettings(QSettings &settings, int argc, char * *argv)
{
// Options like -D My/setting=test
QRegExp rx("([^=]+)=(.*)");
for (int i = 0; i < argc; ++i) {
if (CONFIG_OPTION == QString(argv[i])) {
if (rx.indexIn(argv[++i]) > -1) {
QString key = rx.cap(1);
QString value = rx.cap(2);
qDebug() << "settings - user setting" << key << "set to value" << value;
settings.setValue(key, value);
}
}
}
}
void resetToFactoryDefaults(QSettings &toSettings)
{
toSettings.clear();
applyToFactorySettings(
[&](const QSettings &fromSettings) { copySettings(fromSettings, toSettings); }
);
}
/**
* Merge factory defaults into user settings.
* Currently only Plugins and UAVGadgetConfigurations are merged
*/
void mergeFactoryDefaults(QSettings &toSettings)
{
// registry of all configuration groups ever seen
// used to avoid re-adding a group that was deleted by the user
Registry registry;
// merge all loaded factory defaults
applyToFactorySettings(
[&](const QSettings &fromSettings) { mergeFactorySettings(registry, fromSettings, toSettings); }
);
registry.save();
}
}

25
ground/gcs/src/libs/utils/winutils.h → ground/gcs/src/libs/utils/settingsutils.h
View File

@ -1,8 +1,8 @@
/**
******************************************************************************
*
* @file winutils.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file settingsutils.h
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
@ -26,18 +26,19 @@
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef WINUTILS_H
#define WINUTILS_H
#ifndef SETTINGS_UTILS_H
#define SETTINGS_UTILS_H
#include "utils_global.h"
QT_BEGIN_NAMESPACE
class QString;
QT_END_NAMESPACE
#include <QString>
#include <QSettings>
namespace Utils {
// Helper to format a Windows error message, taking the
// code as returned by the GetLastError()-API.
QTCREATOR_UTILS_EXPORT QString winErrorMessage(unsigned long error);
} // namespace Utils
#endif // WINUTILS_H
QTCREATOR_UTILS_EXPORT void initSettings(const QString &factoryDefaultsFileName);
QTCREATOR_UTILS_EXPORT void overrideSettings(QSettings &settings, int argc, char * *argv);
QTCREATOR_UTILS_EXPORT void resetToFactoryDefaults(QSettings &settings);
QTCREATOR_UTILS_EXPORT void mergeFactoryDefaults(QSettings &settings);
}
#endif /* SETTINGS_UTILS_H */

22
ground/gcs/src/libs/utils/utils.pro
View File

@ -18,7 +18,6 @@ SOURCES += \
linecolumnlabel.cpp \
qtcolorbutton.cpp \
synchronousprocess.cpp \
consoleprocess.cpp \
treewidgetcolumnstretcher.cpp \
checkablemessagebox.cpp \
styledbar.cpp \
@ -29,6 +28,7 @@ SOURCES += \
detailswidget.cpp \
coordinateconversions.cpp \
pathutils.cpp \
settingsutils.cpp \
worldmagmodel.cpp \
homelocationutil.cpp \
mytabbedstackwidget.cpp \
@ -39,18 +39,8 @@ SOURCES += \
logfile.cpp \
crc.cpp \
mustache.cpp \
textbubbleslider.cpp
SOURCES += xmlconfig.cpp
win32 {
SOURCES += \
abstractprocess_win.cpp \
consoleprocess_win.cpp \
winutils.cpp
HEADERS += winutils.h
}
else:SOURCES += consoleprocess_unix.cpp
textbubbleslider.cpp \
xmlconfig.cpp
HEADERS += \
utils_global.h \
@ -74,6 +64,7 @@ HEADERS += \
detailswidget.h \
coordinateconversions.h \
pathutils.h \
settingsutils.h \
worldmagmodel.h \
homelocationutil.h \
mytabbedstackwidget.h \
@ -85,9 +76,8 @@ HEADERS += \
crc.h \
mustache.h \
textbubbleslider.h \
filelogger.h
HEADERS += xmlconfig.h
filelogger.h \
xmlconfig.h
FORMS += \
checkablemessagebox.ui

52
ground/gcs/src/libs/utils/winutils.cpp
View File

@ -1,52 +0,0 @@
/**
******************************************************************************
*
* @file winutils.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* 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
*/
#include "winutils.h"
#include <windows.h>
#include <QtCore/QString>
namespace Utils {
QTCREATOR_UTILS_EXPORT QString winErrorMessage(unsigned long error)
{
QString rc = QString::fromLatin1("#%1: ").arg(error);
ushort *lpMsgBuf;
const int len = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, error, 0, (LPTSTR)&lpMsgBuf, 0, NULL);
if (len) {
rc = QString::fromUtf16(lpMsgBuf, len);
LocalFree(lpMsgBuf);
} else {
rc += QString::fromLatin1("<unknown error>");
}
return rc;
}
} // namespace Utils

51
ground/gcs/src/libs/utils/xmlconfig.cpp
View File

@ -2,13 +2,14 @@
******************************************************************************
*
* @file xmlconfig.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @see The GNU Public License (GPL) Version 3
* @brief Widget for Import/Export Plugin
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup importexportplugin
* @addtogroup utils
* @{
*
*****************************************************************************/
@ -30,24 +31,24 @@
/* Nokia Corporation */
#include "xmlconfig.h"
#include <QtDebug>
#include <QDebug>
#include <QStringList>
#include <QRegExp>
#include <QDataStream>
#include <QVariant>
#include <QRect>
#include <QSize>
#include <QPoint>
#include <QtCore/QUrl>
#include <QUrl>
#include <QDomElement>
#define NUM_PREFIX "arr_"
QString XmlConfig::rootName = "gcs";
const QString XmlConfig::RootName = "gcs";
const QSettings::Format XmlConfig::XmlSettingsFormat =
const QSettings::Format XmlConfig::XmlFormat =
QSettings::registerFormat("xml", XmlConfig::readXmlFile, XmlConfig::writeXmlFile);
bool XmlConfig::readXmlFile(QIODevice &device, QSettings::SettingsMap &map)
{
QDomDocument domDoc;
@ -90,7 +91,7 @@ void XmlConfig::handleNode(QDomElement *node, QSettings::SettingsMap &map, QStri
nodeName = nodeName.replace("__PCT__", "%");
nodeName = QUrl::fromPercentEncoding(nodeName.toLatin1());
if (nodeName == XmlConfig::rootName) {
if (nodeName == XmlConfig::RootName) {
;
} else if (path == "") {
path = nodeName;
@ -98,31 +99,31 @@ void XmlConfig::handleNode(QDomElement *node, QSettings::SettingsMap &map, QStri
path += "/" + nodeName;
}
// qDebug() << "Node: " << ": " << path << " Children: " << node->childNodes().length();
// qDebug() << "Node: " << ": " << path << " Children: " << node->childNodes().length();
for (int i = 0; i < node->childNodes().length(); ++i) {
QDomNode child = node->childNodes().item(i);
if (child.isElement()) {
handleNode(static_cast<QDomElement *>(&child), map, path);
} else if (child.isText()) {
// qDebug() << "Key: " << path << " Value:" << node->text();
// qDebug() << "Key: " << path << " Value:" << node->text();
map.insert(path, stringToVariant(node->text()));
} else {
qDebug() << "Child not Element or text!" << child.nodeType();
}
}
// qDebug() << "XmlConfig::handleNode end";
// qDebug() << "XmlConfig::handleNode end";
}
bool XmlConfig::writeXmlFile(QIODevice &device, const QSettings::SettingsMap &map)
{
QDomDocument outDocument;
// qDebug() << "writeXmlFile start";
outDocument.appendChild(outDocument.createElement(XmlConfig::rootName));
// qDebug() << "writeXmlFile start";
outDocument.appendChild(outDocument.createElement(XmlConfig::RootName));
QMapIterator<QString, QVariant> iter(map);
while (iter.hasNext()) {
iter.next();
// qDebug() << "Entry: " << iter.key() << ": " << iter.value().toString() << endl;
// qDebug() << "Entry: " << iter.key() << ": " << iter.value().toString() << endl;
QDomNode node = outDocument.firstChild();
foreach(QString elem, iter.key().split('/')) {
if (elem == "") {
@ -149,27 +150,11 @@ bool XmlConfig::writeXmlFile(QIODevice &device, const QSettings::SettingsMap &ma
node.appendChild(outDocument.createTextNode(variantToString(iter.value())));
}
device.write(outDocument.toByteArray(2).constData());
// qDebug() << "Dokument:\n" << outDocument.toByteArray(2).constData();
// qDebug() << "writeXmlFile end";
// qDebug() << "Document:\n" << outDocument.toByteArray(2).constData();
// qDebug() << "writeXmlFile end";
return true;
}
QSettings::SettingsMap XmlConfig::settingsToMap(QSettings & qs)
{
qDebug() << "settingsToMap:---------------";
QSettings::SettingsMap map;
QStringList keys = qs.allKeys();
foreach(QString key, keys) {
QVariant val = qs.value(key);
qDebug() << key << val.toString();
map.insert(key, val);
}
qDebug() << "settingsToMap End --------";
return map;
}
QString XmlConfig::variantToString(const QVariant &v)
{
QString result;

18
ground/gcs/src/libs/utils/xmlconfig.h
View File

@ -1,11 +1,13 @@
/**
******************************************************************************
* @file
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
*
* @file xmlconfig.h
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2016.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @see The GNU Public License (GPL) Version 3
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup importexportplugin
* @addtogroup utils
* @{
*****************************************************************************/
/*
@ -34,29 +36,29 @@
#include <QtCore/qglobal.h>
#include <QSettings>
#include <QDomElement>
#include <QObject>
#include <QDataStream>
class QDomElement;
class XMLCONFIG_EXPORT XmlConfig : QObject {
Q_OBJECT
public:
static const QSettings::Format XmlSettingsFormat;
static const QSettings::Format XmlFormat;
static bool readXmlFile(QIODevice &device, QSettings::SettingsMap &map);
static bool writeXmlFile(QIODevice &device, const QSettings::SettingsMap &map);
private:
static QString rootName;
static const QString RootName;
static void handleNode(QDomElement *node, QSettings::SettingsMap &map, QString path = "");
static QSettings::SettingsMap settingsToMap(QSettings & qs);
static QString variantToString(const QVariant &v);
static QVariant stringToVariant(const QString &s);
static QStringList splitArgs(const QString &s, int idx);
};
#endif // XMLCONFIG_H
/**
* @}
* @}

90
ground/gcs/src/plugins/antennatrack/antennatrackgadgetconfiguration.cpp
View File

@ -26,83 +26,59 @@
*/
#include "antennatrackgadgetconfiguration.h"
#include <QtSerialPort/QSerialPort>
/**
* Loads a saved configuration or defaults if non exist.
*
*/
AntennaTrackGadgetConfiguration::AntennaTrackGadgetConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent),
m_connectionMode("Serial"),
m_defaultPort("Unknown"),
m_defaultSpeed(QSerialPort::UnknownBaud),
m_defaultDataBits(QSerialPort::UnknownDataBits),
m_defaultFlow(QSerialPort::UnknownFlowControl),
m_defaultParity(QSerialPort::UnknownParity),
m_defaultStopBits(QSerialPort::UnknownStopBits),
m_defaultTimeOut(5000)
AntennaTrackGadgetConfiguration::AntennaTrackGadgetConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
// if a saved configuration exists load it
if (qSettings != 0) {
QSerialPort::BaudRate speed;
QSerialPort::DataBits databits;
QSerialPort::FlowControl flow;
QSerialPort::Parity parity;
QSerialPort::StopBits stopbits;
m_defaultPort = settings.value("defaultPort", "Unknown").toString();
m_defaultSpeed = (QSerialPort::BaudRate)settings.value("defaultSpeed", QSerialPort::UnknownBaud).toInt();
m_defaultDataBits = (QSerialPort::DataBits)settings.value("defaultDataBits", QSerialPort::UnknownDataBits).toInt();
m_defaultFlow = (QSerialPort::FlowControl)settings.value("defaultFlow", QSerialPort::UnknownFlowControl).toInt();
m_defaultParity = (QSerialPort::Parity)settings.value("defaultParity", QSerialPort::UnknownParity).toInt();
m_defaultStopBits = (QSerialPort::StopBits)settings.value("defaultStopBits", QSerialPort::UnknownStopBits).toInt();
m_connectionMode = (QSerialPort::BaudRate)settings.value("connectionMode", "Serial").toString();
m_defaultTimeOut = 5000;
}
int ispeed = qSettings->value("defaultSpeed").toInt();
int idatabits = qSettings->value("defaultDataBits").toInt();
int iflow = qSettings->value("defaultFlow").toInt();
int iparity = qSettings->value("defaultParity").toInt();
int istopbits = qSettings->value("defaultStopBits").toInt();
QString port = qSettings->value("defaultPort").toString();
QString conMode = qSettings->value("connectionMode").toString();
databits = (QSerialPort::DataBits)idatabits;
flow = (QSerialPort::FlowControl)iflow;
parity = (QSerialPort::Parity)iparity;
stopbits = (QSerialPort::StopBits)istopbits;
speed = (QSerialPort::BaudRate)ispeed;
m_defaultPort = port;
m_defaultSpeed = speed;
m_defaultDataBits = databits;
m_defaultFlow = flow;
m_defaultParity = parity;
m_defaultStopBits = stopbits;
m_connectionMode = conMode;
}
AntennaTrackGadgetConfiguration::AntennaTrackGadgetConfiguration(const AntennaTrackGadgetConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
m_defaultSpeed = obj.m_defaultSpeed;
m_defaultDataBits = obj.m_defaultDataBits;
m_defaultFlow = obj.m_defaultFlow;
m_defaultParity = obj.m_defaultParity;
m_defaultStopBits = obj.m_defaultStopBits;
m_defaultPort = obj.m_defaultPort;
m_connectionMode = obj.m_connectionMode;
m_defaultTimeOut = obj.m_defaultTimeOut;
}
/**
* Clones a configuration.
*
*/
IUAVGadgetConfiguration *AntennaTrackGadgetConfiguration::clone()
IUAVGadgetConfiguration *AntennaTrackGadgetConfiguration::clone() const
{
AntennaTrackGadgetConfiguration *m = new AntennaTrackGadgetConfiguration(this->classId());
m->m_defaultSpeed = m_defaultSpeed;
m->m_defaultDataBits = m_defaultDataBits;
m->m_defaultFlow = m_defaultFlow;
m->m_defaultParity = m_defaultParity;
m->m_defaultStopBits = m_defaultStopBits;
m->m_defaultPort = m_defaultPort;
m->m_connectionMode = m_connectionMode;
return m;
return new AntennaTrackGadgetConfiguration(*this);
}
/**
* Saves a configuration.
*
*/
void AntennaTrackGadgetConfiguration::saveConfig(QSettings *settings) const
void AntennaTrackGadgetConfiguration::saveConfig(QSettings &settings) const
{
settings->setValue("defaultSpeed", m_defaultSpeed);
settings->setValue("defaultDataBits", m_defaultDataBits);
settings->setValue("defaultFlow", m_defaultFlow);
settings->setValue("defaultParity", m_defaultParity);
settings->setValue("defaultStopBits", m_defaultStopBits);
settings->setValue("defaultPort", m_defaultPort);
settings->setValue("connectionMode", m_connectionMode);
settings.setValue("defaultSpeed", m_defaultSpeed);
settings.setValue("defaultDataBits", m_defaultDataBits);
settings.setValue("defaultFlow", m_defaultFlow);
settings.setValue("defaultParity", m_defaultParity);
settings.setValue("defaultStopBits", m_defaultStopBits);
settings.setValue("defaultPort", m_defaultPort);
settings.setValue("connectionMode", m_connectionMode);
}

12
ground/gcs/src/plugins/antennatrack/antennatrackgadgetconfiguration.h
View File

@ -29,6 +29,7 @@
#define ANTENNATRACKGADGETCONFIGURATION_H
#include <coreplugin/iuavgadgetconfiguration.h>
#include <QtSerialPort/QSerialPort>
using namespace Core;
@ -45,11 +46,14 @@ struct PortSettings {
long Timeout_Millisec;
};
class AntennaTrackGadgetConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT
public:
explicit AntennaTrackGadgetConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit AntennaTrackGadgetConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit AntennaTrackGadgetConfiguration(const AntennaTrackGadgetConfiguration &obj);
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
void setConnectionMode(QString mode)
{
@ -59,7 +63,6 @@ public:
{
return m_connectionMode;
}
// set port configuration functions
void setSpeed(QSerialPort::BaudRate speed)
{
@ -120,9 +123,6 @@ public:
return m_defaultTimeOut;
}
void saveConfig(QSettings *settings) const;
IUAVGadgetConfiguration *clone();
private:
QString m_connectionMode;
QString m_defaultPort;

4
ground/gcs/src/plugins/antennatrack/antennatrackgadgetfactory.cpp
View File

@ -47,9 +47,9 @@ Core::IUAVGadget *AntennaTrackGadgetFactory::createGadget(QWidget *parent)
return new AntennaTrackGadget(QString("AntennaTrackGadget"), gadgetWidget, parent);
}
IUAVGadgetConfiguration *AntennaTrackGadgetFactory::createConfiguration(QSettings *qSettings)
IUAVGadgetConfiguration *AntennaTrackGadgetFactory::createConfiguration(QSettings &settings)
{
return new AntennaTrackGadgetConfiguration(QString("AntennaTrackGadget"), qSettings);
return new AntennaTrackGadgetConfiguration(QString("AntennaTrackGadget"), settings);
}
IOptionsPage *AntennaTrackGadgetFactory::createOptionsPage(IUAVGadgetConfiguration *config)

2
ground/gcs/src/plugins/antennatrack/antennatrackgadgetfactory.h
View File

@ -44,7 +44,7 @@ public:
~AntennaTrackGadgetFactory();
Core::IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(QSettings *qSettings);
IUAVGadgetConfiguration *createConfiguration(QSettings &settings);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};

4
ground/gcs/src/plugins/config/configgadget.cpp
View File

@ -45,12 +45,12 @@ void ConfigGadget::loadConfiguration(IUAVGadgetConfiguration *config)
Q_UNUSED(config);
}
void ConfigGadget::saveState(QSettings *settings)
void ConfigGadget::saveState(QSettings &settings) const
{
m_widget->saveState(settings);
}
void ConfigGadget::restoreState(QSettings *settings)
void ConfigGadget::restoreState(QSettings &settings)
{
m_widget->restoreState(settings);
}

4
ground/gcs/src/plugins/config/configgadget.h
View File

@ -49,8 +49,8 @@ public:
void loadConfiguration(IUAVGadgetConfiguration *config);
void saveState(QSettings *settings);
void restoreState(QSettings *settings);
void saveState(QSettings &settings) const;
void restoreState(QSettings &settings);
private:
ConfigGadgetWidget *m_widget;

8
ground/gcs/src/plugins/config/configgadgetwidget.cpp
View File

@ -180,14 +180,14 @@ void ConfigGadgetWidget::startInputWizard()
inputWidget->startInputWizard();
}
void ConfigGadgetWidget::saveState(QSettings *settings)
void ConfigGadgetWidget::saveState(QSettings &settings) const
{
settings->setValue("currentIndex", stackWidget->currentIndex());
settings.setValue("currentIndex", stackWidget->currentIndex());
}
void ConfigGadgetWidget::restoreState(QSettings *settings)
void ConfigGadgetWidget::restoreState(QSettings &settings)
{
int index = settings->value("currentIndex", 0).toInt();
int index = settings.value("currentIndex", 0).toInt();
stackWidget->setCurrentIndex(index);
}

4
ground/gcs/src/plugins/config/configgadgetwidget.h
View File

@ -45,8 +45,8 @@ public:
void startInputWizard();
void saveState(QSettings *settings);
void restoreState(QSettings *settings);
void saveState(QSettings &settings) const;
void restoreState(QSettings &settings);
protected:
void resizeEvent(QResizeEvent *event);

24
ground/gcs/src/plugins/coreplugin/actionmanager/actionmanager.cpp
View File

@ -481,14 +481,14 @@ static const char *settingsGroup = "KeyBindings";
static const char *idKey = "ID";
static const char *sequenceKey = "Keysequence";
void ActionManagerPrivate::readSettings(QSettings *settings)
void ActionManagerPrivate::readSettings(QSettings &settings)
{
const int shortcuts = settings->beginReadArray(QLatin1String(settingsGroup));
const int shortcuts = settings.beginReadArray(QLatin1String(settingsGroup));
for (int i = 0; i < shortcuts; ++i) {
settings->setArrayIndex(i);
const QString sid = settings->value(QLatin1String(idKey)).toString();
const QKeySequence key(settings->value(QLatin1String(sequenceKey)).toString());
settings.setArrayIndex(i);
const QString sid = settings.value(QLatin1String(idKey)).toString();
const QKeySequence key(settings.value(QLatin1String(sequenceKey)).toString());
const int id = UniqueIDManager::instance()->uniqueIdentifier(sid);
Command *cmd = command(id);
@ -496,12 +496,12 @@ void ActionManagerPrivate::readSettings(QSettings *settings)
cmd->setKeySequence(key);
}
}
settings->endArray();
settings.endArray();
}
void ActionManagerPrivate::saveSettings(QSettings *settings)
void ActionManagerPrivate::saveSettings(QSettings &settings) const
{
settings->beginWriteArray(QLatin1String(settingsGroup));
settings.beginWriteArray(QLatin1String(settingsGroup));
int count = 0;
const IdCmdMap::const_iterator cmdcend = m_idCmdMap.constEnd();
@ -511,12 +511,12 @@ void ActionManagerPrivate::saveSettings(QSettings *settings)
QKeySequence key = cmd->keySequence();
if (key != cmd->defaultKeySequence()) {
const QString sid = UniqueIDManager::instance()->stringForUniqueIdentifier(id);
settings->setArrayIndex(count);
settings->setValue(QLatin1String(idKey), sid);
settings->setValue(QLatin1String(sequenceKey), key.toString());
settings.setArrayIndex(count);
settings.setValue(QLatin1String(idKey), sid);
settings.setValue(QLatin1String(sequenceKey), key.toString());
count++;
}
}
settings->endArray();
settings.endArray();
}

12
ground/gcs/src/plugins/coreplugin/actionmanager/actionmanager_p.h
View File

@ -31,9 +31,9 @@
#include <coreplugin/actionmanager/actionmanager.h>
#include <QtCore/QMap>
#include <QtCore/QHash>
#include <QtCore/QMultiHash>
#include <QMap>
#include <QHash>
#include <QMultiHash>
QT_BEGIN_NAMESPACE
class QSettings;
@ -62,7 +62,9 @@ public:
void setContext(const QList<int> &context);
static ActionManagerPrivate *instance();
void saveSettings(QSettings *settings);
void saveSettings(QSettings &settings) const;
void readSettings(QSettings &settings);
QList<int> defaultGroups() const;
QList<CommandPrivate *> commands() const;
@ -73,8 +75,6 @@ public:
Command *command(int uid) const;
ActionContainer *actionContainer(int uid) const;
void readSettings(QSettings *settings);
// ActionManager Interface
ActionContainer *createMenu(const QString &id);
ActionContainer *createMenuBar(const QString &id);

44
ground/gcs/src/plugins/coreplugin/coreimpl.cpp
View File

@ -28,11 +28,11 @@
#include "coreimpl.h"
#include <QtCore/QDir>
#include <QtCore/QCoreApplication>
#include "utils/pathutils.h"
#include <QDir>
#include <QSettings>
namespace Core {
namespace Internal {
// The Core Singleton
@ -117,11 +117,6 @@ MimeDatabase *CoreImpl::mimeDatabase() const
return m_mainwindow->mimeDatabase();
}
QSettings *CoreImpl::settings(QSettings::Scope scope) const
{
return m_mainwindow->settings(scope);
}
SettingsDatabase *CoreImpl::settingsDatabase() const
{
return m_mainwindow->settingsDatabase();
@ -137,7 +132,6 @@ IContext *CoreImpl::currentContextObject() const
return m_mainwindow->currentContextObject();
}
QMainWindow *CoreImpl::mainWindow() const
{
return m_mainwindow;
@ -181,24 +175,40 @@ void CoreImpl::openFiles(const QStringList &arguments)
// m_mainwindow->openFiles(arguments);
}
void CoreImpl::readMainSettings(QSettings *qs, bool workspaceDiffOnly)
void CoreImpl::readSettings(IConfigurablePlugin *plugin)
{
m_mainwindow->readSettings(qs, workspaceDiffOnly);
QSettings settings;
readSettings(plugin, settings);
}
void CoreImpl::saveMainSettings(QSettings *qs)
void CoreImpl::saveSettings(IConfigurablePlugin *plugin) const
{
m_mainwindow->saveSettings(qs);
QSettings settings;
saveSettings(plugin, settings);
}
void CoreImpl::readSettings(IConfigurablePlugin *plugin, QSettings *qs)
void CoreImpl::readMainSettings(QSettings &settings, bool workspaceDiffOnly)
{
m_mainwindow->readSettings(plugin, qs);
m_mainwindow->readSettings(settings, workspaceDiffOnly);
}
void CoreImpl::saveSettings(IConfigurablePlugin *plugin, QSettings *qs)
void CoreImpl::saveMainSettings(QSettings &settings) const
{
m_mainwindow->saveSettings(plugin, qs);
m_mainwindow->saveSettings(settings);
}
void CoreImpl::readSettings(IConfigurablePlugin *plugin, QSettings &settings)
{
m_mainwindow->readSettings(plugin, settings);
}
void CoreImpl::saveSettings(IConfigurablePlugin *plugin, QSettings &settings) const
{
m_mainwindow->saveSettings(plugin, settings);
}
void CoreImpl::deleteSettings()
{
m_mainwindow->deleteSettings();

12
ground/gcs/src/plugins/coreplugin/coreimpl.h
View File

@ -60,12 +60,14 @@ public:
ModeManager *modeManager() const;
MimeDatabase *mimeDatabase() const;
QSettings *settings(QSettings::Scope scope = QSettings::UserScope) const;
SettingsDatabase *settingsDatabase() const;
void readMainSettings(QSettings *qs, bool workspaceDiffOnly);
void saveMainSettings(QSettings *qs);
void readSettings(IConfigurablePlugin *plugin, QSettings *qs = 0);
void saveSettings(IConfigurablePlugin *plugin, QSettings *qs = 0);
void readMainSettings(QSettings &settings, bool workspaceDiffOnly);
void saveMainSettings(QSettings &settings) const;
void readSettings(IConfigurablePlugin *plugin);
void saveSettings(IConfigurablePlugin *plugin) const;
void readSettings(IConfigurablePlugin *plugin, QSettings &settings);
void saveSettings(IConfigurablePlugin *plugin, QSettings &settings) const;
void deleteSettings();
QString resourcePath() const;

44
ground/gcs/src/plugins/coreplugin/dialogs/settingsdialog.cpp
View File

@ -33,8 +33,8 @@
#include "coreplugin/uavgadgetinstancemanager.h"
#include "coreplugin/uavgadgetoptionspagedecorator.h"
#include <QtCore/QDebug>
#include <QtCore/QSettings>
#include <QDebug>
#include <QSettings>
#include <QHeaderView>
#include <QLabel>
#include <QPushButton>
@ -96,10 +96,10 @@ Q_DECLARE_METATYPE(::PageData) SettingsDialog::SettingsDialog(QWidget *parent, c
setWindowTitle(tr("Options"));
#endif
QSettings *settings = ICore::instance()->settings();
QSettings settings;
settings->beginGroup("General");
settings->beginGroup("Settings");
settings.beginGroup("General");
settings.beginGroup("Settings");
// restore last displayed category and page
// this is done only if no category or page was provided through the constructor
@ -107,28 +107,28 @@ Q_DECLARE_METATYPE(::PageData) SettingsDialog::SettingsDialog(QWidget *parent, c
QString initialPage = pageId;
qDebug() << "SettingsDialog constructor initial category:" << initialCategory << ", initial page:" << initialPage;
if (initialCategory.isEmpty() && initialPage.isEmpty()) {
initialCategory = settings->value("LastPreferenceCategory", QVariant(QString())).toString();
initialPage = settings->value("LastPreferencePage", QVariant(QString())).toString();
initialCategory = settings.value("LastPreferenceCategory", QVariant(QString())).toString();
initialPage = settings.value("LastPreferencePage", QVariant(QString())).toString();
qDebug() << "SettingsDialog settings initial category:" << initialCategory << ", initial page: " << initialPage;
}
// restore window size
int windowWidth = settings->value("WindowWidth", 0).toInt();
int windowHeight = settings->value("WindowHeight", 0).toInt();
int windowWidth = settings.value("WindowWidth", 0).toInt();
int windowHeight = settings.value("WindowHeight", 0).toInt();
qDebug() << "SettingsDialog window width :" << windowWidth << ", height:" << windowHeight;
if (windowWidth > 0 && windowHeight > 0) {
resize(windowWidth, windowHeight);
}
// restore splitter size
int splitterPosition = settings->value("SplitterPosition", 350).toInt();
int splitterPosition = settings.value("SplitterPosition", 350).toInt();
qDebug() << "SettingsDialog splitter position:" << splitterPosition;
QList<int> sizes;
sizes << splitterPosition << 400;
splitter->setSizes(sizes);
settings->endGroup();
settings->endGroup();
settings.endGroup();
settings.endGroup();
// all extra space must go to the option page and none to the tree
splitter->setStretchFactor(0, 0);
@ -464,22 +464,22 @@ bool SettingsDialog::execDialog()
void SettingsDialog::done(int val)
{
QSettings *settings = ICore::instance()->settings();
QSettings settings;
settings->beginGroup("General");
settings->beginGroup("Settings");
settings.beginGroup("General");
settings.beginGroup("Settings");
settings->setValue("LastPreferenceCategory", m_currentCategory);
settings->setValue("LastPreferencePage", m_currentPage);
settings.setValue("LastPreferenceCategory", m_currentCategory);
settings.setValue("LastPreferencePage", m_currentPage);
settings->setValue("WindowWidth", this->width());
settings->setValue("WindowHeight", this->height());
settings.setValue("WindowWidth", this->width());
settings.setValue("WindowHeight", this->height());
QList<int> sizes = splitter->sizes();
settings->setValue("SplitterPosition", sizes[0]);
settings.setValue("SplitterPosition", sizes[0]);
settings->endGroup();
settings->endGroup();
settings.endGroup();
settings.endGroup();
QDialog::done(val);
}

2
ground/gcs/src/plugins/coreplugin/dialogs/settingsdialog.h
View File

@ -31,7 +31,7 @@
#include "ui_settingsdialog.h"
#include <QtCore/QList>
#include <QList>
#include "coreplugin/dialogs/ioptionspage.h"

51
ground/gcs/src/plugins/coreplugin/generalsettings.cpp
View File

@ -33,7 +33,6 @@
#include <utils/stylehelper.h>
#include <utils/qtcolorbutton.h>
#include <utils/consoleprocess.h>
#include <coreplugin/icore.h>
#include <QMessageBox>
@ -157,40 +156,40 @@ void GeneralSettings::finish()
delete m_page;
}
void GeneralSettings::readSettings(QSettings *qs)
void GeneralSettings::readSettings(QSettings &settings)
{
qs->beginGroup(QLatin1String("General"));
m_language = qs->value(QLatin1String("OverrideLanguage"), QLocale::system().name()).toString();
m_saveSettingsOnExit = qs->value(QLatin1String("SaveSettingsOnExit"), m_saveSettingsOnExit).toBool();
m_autoConnect = qs->value(QLatin1String("AutoConnect"), m_autoConnect).toBool();
m_autoSelect = qs->value(QLatin1String("AutoSelect"), m_autoSelect).toBool();
m_useUDPMirror = qs->value(QLatin1String("UDPMirror"), m_useUDPMirror).toBool();
m_useExpertMode = qs->value(QLatin1String("ExpertMode"), m_useExpertMode).toBool();
m_collectUsageData = qs->value(QLatin1String("CollectUsageData"), m_collectUsageData).toBool();
m_showUsageDataDisclaimer = qs->value(QLatin1String("ShowUsageDataDisclaimer"), m_showUsageDataDisclaimer).toBool();
m_lastUsageHash = qs->value(QLatin1String("LastUsageHash"), m_lastUsageHash).toString();
qs->endGroup();
settings.beginGroup(QLatin1String("General"));
m_language = settings.value(QLatin1String("OverrideLanguage"), QLocale::system().name()).toString();
m_saveSettingsOnExit = settings.value(QLatin1String("SaveSettingsOnExit"), m_saveSettingsOnExit).toBool();
m_autoConnect = settings.value(QLatin1String("AutoConnect"), m_autoConnect).toBool();
m_autoSelect = settings.value(QLatin1String("AutoSelect"), m_autoSelect).toBool();
m_useUDPMirror = settings.value(QLatin1String("UDPMirror"), m_useUDPMirror).toBool();
m_useExpertMode = settings.value(QLatin1String("ExpertMode"), m_useExpertMode).toBool();
m_collectUsageData = settings.value(QLatin1String("CollectUsageData"), m_collectUsageData).toBool();
m_showUsageDataDisclaimer = settings.value(QLatin1String("ShowUsageDataDisclaimer"), m_showUsageDataDisclaimer).toBool();
m_lastUsageHash = settings.value(QLatin1String("LastUsageHash"), m_lastUsageHash).toString();
settings.endGroup();
}
void GeneralSettings::saveSettings(QSettings *qs)
void GeneralSettings::saveSettings(QSettings &settings) const
{
qs->beginGroup(QLatin1String("General"));
settings.beginGroup(QLatin1String("General"));
if (m_language.isEmpty()) {
qs->remove(QLatin1String("OverrideLanguage"));
settings.remove(QLatin1String("OverrideLanguage"));
} else {
qs->setValue(QLatin1String("OverrideLanguage"), m_language);
settings.setValue(QLatin1String("OverrideLanguage"), m_language);
}
qs->setValue(QLatin1String("SaveSettingsOnExit"), m_saveSettingsOnExit);
qs->setValue(QLatin1String("AutoConnect"), m_autoConnect);
qs->setValue(QLatin1String("AutoSelect"), m_autoSelect);
qs->setValue(QLatin1String("UDPMirror"), m_useUDPMirror);
qs->setValue(QLatin1String("ExpertMode"), m_useExpertMode);
qs->setValue(QLatin1String("CollectUsageData"), m_collectUsageData);
qs->setValue(QLatin1String("ShowUsageDataDisclaimer"), m_showUsageDataDisclaimer);
qs->setValue(QLatin1String("LastUsageHash"), m_lastUsageHash);
qs->endGroup();
settings.setValue(QLatin1String("SaveSettingsOnExit"), m_saveSettingsOnExit);
settings.setValue(QLatin1String("AutoConnect"), m_autoConnect);
settings.setValue(QLatin1String("AutoSelect"), m_autoSelect);
settings.setValue(QLatin1String("UDPMirror"), m_useUDPMirror);
settings.setValue(QLatin1String("ExpertMode"), m_useExpertMode);
settings.setValue(QLatin1String("CollectUsageData"), m_collectUsageData);
settings.setValue(QLatin1String("ShowUsageDataDisclaimer"), m_showUsageDataDisclaimer);
settings.setValue(QLatin1String("LastUsageHash"), m_lastUsageHash);
settings.endGroup();
}
void GeneralSettings::resetInterfaceColor()

7
ground/gcs/src/plugins/coreplugin/generalsettings.h
View File

@ -33,7 +33,8 @@
#include <QPointer>
#include <QWidget>
#include <QSettings>
class QSettings;
namespace Core {
namespace Internal {
@ -61,8 +62,8 @@ public:
bool collectUsageData() const;
bool showUsageDataDisclaimer() const;
QString lastUsageHash() const;
void readSettings(QSettings *qs);
void saveSettings(QSettings *qs);
void readSettings(QSettings &settings);
void saveSettings(QSettings &settings) const;
bool useExpertMode() const;
void setCollectUsageData(bool collect);
void setShowUsageDataDisclaimer(bool show);

5
ground/gcs/src/plugins/coreplugin/iconfigurableplugin.h
View File

@ -12,10 +12,9 @@ namespace Core {
class CORE_EXPORT IConfigurablePlugin : public ExtensionSystem::IPlugin {
Q_OBJECT
public:
// IConfigurablePlugin(QObject *parent = 0){}
virtual ~IConfigurablePlugin() {}
virtual void readConfig(QSettings *qSettings, UAVConfigInfo *configInfo) = 0;
virtual void saveConfig(QSettings *qSettings, Core::UAVConfigInfo *configInfo) = 0;
virtual void readConfig(QSettings &settings, UAVConfigInfo *configInfo) = 0;
virtual void saveConfig(QSettings &settings, UAVConfigInfo *configInfo) const = 0;
};
} // namespace Core

18
ground/gcs/src/plugins/coreplugin/icore.cpp
View File

@ -172,24 +172,6 @@
Use the mime database to manage mime types.
*/
/*!
\fn QSettings *ICore::settings(QSettings::UserScope scope) const
\brief Returns the application's main settings object.
You can use it to retrieve or set application wide settings
(in contrast to session or project specific settings).
If \a scope is QSettings::UserScope (the default), the
users settings will be read from the users settings, with
a fallback to global settings provided with Qt Creator.
If \a scope is QSettings::SystemScope, only the system settings
shipped with the current version of Qt Creator will be read. This
functionality exists for internal purposes only.
\see settingsDatabase()
*/
/*!
\fn SettingsDatabase *ICore::settingsDatabase() const
\brief Returns the application's settings database.

17
ground/gcs/src/plugins/coreplugin/icore.h
View File

@ -30,13 +30,12 @@
#define ICORE_H
#include "core_global.h"
#include <QtCore/QObject>
#include <QSettings>
#include <QObject>
QT_BEGIN_NAMESPACE
class QMainWindow;
class QSettings;
template <class T> class QList;
QT_END_NAMESPACE
namespace Core {
@ -84,12 +83,14 @@ public:
virtual UAVGadgetInstanceManager *uavGadgetInstanceManager() const = 0;
virtual MimeDatabase *mimeDatabase() const = 0;
virtual QSettings *settings(QSettings::Scope scope = QSettings::UserScope) const = 0;
virtual SettingsDatabase *settingsDatabase() const = 0;
virtual void readMainSettings(QSettings *qs, bool workspaceDiffOnly = false) = 0;
virtual void saveMainSettings(QSettings *qs) = 0;
virtual void readSettings(IConfigurablePlugin *plugin, QSettings *qs = 0) = 0;
virtual void saveSettings(IConfigurablePlugin *plugin, QSettings *qs = 0) = 0;
virtual void readMainSettings(QSettings &settings, bool workspaceDiffOnly = false) = 0;
virtual void saveMainSettings(QSettings &settings) const = 0;
virtual void readSettings(IConfigurablePlugin *plugin) = 0;
virtual void saveSettings(IConfigurablePlugin *plugin) const = 0;
virtual void readSettings(IConfigurablePlugin *plugin, QSettings &settings) = 0;
virtual void saveSettings(IConfigurablePlugin *plugin, QSettings &settings) const = 0;
virtual void deleteSettings() = 0;
virtual QString resourcePath() const = 0;

4
ground/gcs/src/plugins/coreplugin/iuavgadget.h
View File

@ -77,9 +77,9 @@ public:
return 0;
}
virtual void loadConfiguration(IUAVGadgetConfiguration *) {}
virtual void saveState(QSettings * /*qSettings*/) {}
virtual void saveState(QSettings &) const {}
virtual void restoreState(QByteArray) {}
virtual void restoreState(QSettings * /*qSettings*/) {}
virtual void restoreState(QSettings &) {}
public slots:
virtual void configurationChanged(IUAVGadgetConfiguration *) {}
virtual void configurationAdded(IUAVGadgetConfiguration *) {}

4
ground/gcs/src/plugins/coreplugin/iuavgadgetconfiguration.cpp
View File

@ -31,8 +31,8 @@ using namespace Core;
IUAVGadgetConfiguration::IUAVGadgetConfiguration(QString classId, QObject *parent) :
QObject(parent),
m_locked(false),
m_classId(classId),
m_name(tr("default")),
m_provisionalName(tr("default"))
m_provisionalName(tr("default")),
m_locked(false)
{}

22
ground/gcs/src/plugins/coreplugin/iuavgadgetconfiguration.h
View File

@ -40,52 +40,60 @@ class CORE_EXPORT IUAVGadgetConfiguration : public QObject {
Q_OBJECT
public:
explicit IUAVGadgetConfiguration(QString classId, QObject *parent = 0);
QString classId()
QString classId() const
{
return m_classId;
}
QString name()
QString name() const
{
return m_name;
}
void setName(QString name)
{
m_name = name;
}
QString provisionalName()
QString provisionalName() const
{
return m_provisionalName;
}
void setProvisionalName(QString name)
{
m_provisionalName = name;
}
bool locked() const
{
return m_locked;
}
void setLocked(bool locked)
{
m_locked = locked;
}
virtual void saveConfig(QSettings * /*settings*/) const {}
virtual void saveConfig(QSettings *settings, UAVConfigInfo * /*configInfo*/) const
virtual void saveConfig(QSettings &) const {}
virtual void saveConfig(QSettings &settings, UAVConfigInfo *) const
{
saveConfig(settings);
}
virtual IUAVGadgetConfiguration *clone() = 0;
virtual IUAVGadgetConfiguration *clone() const = 0;
signals:
public slots:
private:
bool m_locked;
QString m_classId;
QString m_name;
QString m_provisionalName;
bool m_locked;
};
} // namespace Core

16
ground/gcs/src/plugins/coreplugin/iuavgadgetfactory.h
View File

@ -28,15 +28,17 @@
#ifndef IUAVGADGETFACTORY_H
#define IUAVGADGETFACTORY_H
#include "core_global.h"
#include <QtCore/QObject>
#include <QIcon>
#include <QSettings>
#include "uavconfiginfo.h"
#include <QObject>
#include <QIcon>
QT_BEGIN_NAMESPACE
class QStringList;
class QSettings;
QT_END_NAMESPACE
namespace Core {
@ -56,15 +58,15 @@ public:
virtual ~IUAVGadgetFactory() {}
virtual IUAVGadget *createGadget(QWidget *parent) = 0;
virtual IUAVGadgetConfiguration *createConfiguration(QSettings * /*qSettings*/)
virtual IUAVGadgetConfiguration *createConfiguration(QSettings &)
{
return 0;
}
virtual IUAVGadgetConfiguration *createConfiguration(QSettings *qs, UAVConfigInfo * /*configInfo*/)
virtual IUAVGadgetConfiguration *createConfiguration(QSettings &settings, UAVConfigInfo *)
{
return createConfiguration(qs);
return createConfiguration(settings);
}
virtual IOptionsPage *createOptionsPage(IUAVGadgetConfiguration * /*config*/)
virtual IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *)
{
return 0;
}

227
ground/gcs/src/plugins/coreplugin/mainwindow.cpp
View File

@ -65,7 +65,6 @@
#include <utils/pathchooser.h>
#include <utils/pathutils.h>
#include <utils/stylehelper.h>
#include <utils/xmlconfig.h>
#include "version_info/version_info.h"
#include <QtCore/QDebug>
@ -102,13 +101,6 @@ MainWindow::MainWindow() :
m_uniqueIDManager(new UniqueIDManager()),
m_globalContext(QList<int>() << Constants::C_GLOBAL_ID),
m_additionalContexts(m_globalContext),
// keep this in sync with main() in app/main.cpp
m_settings(new QSettings(this)),
m_globalSettings(new QSettings(XmlConfig::XmlSettingsFormat, QSettings::SystemScope,
m_settings->organizationName(), m_settings->applicationName(), this)),
m_settingsDatabase(new SettingsDatabase(QFileInfo(m_settings->fileName()).path(),
QFileInfo(m_settings->fileName()).baseName(),
this)),
m_dontSaveSettings(false),
m_actionManager(new ActionManagerPrivate(this)),
m_variableManager(new VariableManager(this)),
@ -140,6 +132,11 @@ MainWindow::MainWindow() :
#endif
qApp->setStyle(QStyleFactory::create("Fusion"));
QSettings settings;
m_settingsDatabase = new SettingsDatabase(QFileInfo(settings.fileName()).path(),
QFileInfo(settings.fileName()).baseName(),
this);
setDockNestingEnabled(true);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
@ -200,10 +197,8 @@ MainWindow::~MainWindow()
m_generalSettings = 0;
delete m_workspaceSettings;
m_workspaceSettings = 0;
delete m_settings;
m_settings = 0;
delete m_uniqueIDManager;
m_uniqueIDManager = 0;
m_uniqueIDManager = 0;
pm->removeObject(m_coreImpl);
delete m_coreImpl;
@ -236,13 +231,13 @@ void MainWindow::modeChanged(Core::IMode * /*mode*/)
void MainWindow::extensionsInitialized()
{
QSettings *qs = m_settings;
QSettings settings;
qs->beginGroup("General");
settings.beginGroup("General");
m_config_description = qs->value("Description", "none").toString();
m_config_details = qs->value("Details", "none").toString();
m_config_stylesheet = qs->value("StyleSheet", "none").toString();
m_config_description = settings.value("Description", "none").toString();
m_config_details = settings.value("Details", "none").toString();
m_config_stylesheet = settings.value("StyleSheet", "none").toString();
qDebug() << "Configured style sheet:" << m_config_stylesheet;
if (m_config_stylesheet == "wide") {
@ -269,13 +264,14 @@ void MainWindow::extensionsInitialized()
// qDebug() << "Setting application style sheet to:" << style;
qApp->setStyleSheet(style);
qs->endGroup();
settings.endGroup();
m_uavGadgetInstanceManager = new UAVGadgetInstanceManager(this);
m_uavGadgetInstanceManager->readSettings(qs);
m_uavGadgetInstanceManager->readSettings(settings);
m_messageManager->init();
readSettings(qs);
readSettings(settings);
updateContext();
@ -323,8 +319,9 @@ void MainWindow::closeEvent(QCloseEvent *event)
emit m_coreImpl->coreAboutToClose();
if (!m_dontSaveSettings) {
saveSettings(m_settings);
m_uavGadgetInstanceManager->saveSettings(m_settings);
QSettings settings;
saveSettings(settings);
m_uavGadgetInstanceManager->saveSettings(settings);
}
qApp->closeAllWindows();
@ -477,31 +474,31 @@ void MainWindow::registerDefaultActions()
ActionContainer *mhelp = am->actionContainer(Constants::M_HELP);
// File menu separators
Command *cmd = createSeparator(am, this, QLatin1String("QtCreator.File.Sep.Save"), m_globalContext);
Command *cmd = createSeparator(am, this, "QtCreator.File.Sep.Save", m_globalContext);
mfile->addAction(cmd, Constants::G_FILE_SAVE);
cmd = createSeparator(am, this, QLatin1String("QtCreator.File.Sep.Close"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.File.Sep.Close", m_globalContext);
mfile->addAction(cmd, Constants::G_FILE_CLOSE);
cmd = createSeparator(am, this, QLatin1String("QtCreator.File.Sep.Other"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.File.Sep.Other", m_globalContext);
mfile->addAction(cmd, Constants::G_FILE_OTHER);
// Edit menu separators
cmd = createSeparator(am, this, QLatin1String("QtCreator.Edit.Sep.CopyPaste"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.Edit.Sep.CopyPaste", m_globalContext);
medit->addAction(cmd, Constants::G_EDIT_COPYPASTE);
cmd = createSeparator(am, this, QLatin1String("QtCreator.Edit.Sep.SelectAll"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.Edit.Sep.SelectAll", m_globalContext);
medit->addAction(cmd, Constants::G_EDIT_SELECTALL);
cmd = createSeparator(am, this, QLatin1String("QtCreator.Edit.Sep.Find"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.Edit.Sep.Find", m_globalContext);
medit->addAction(cmd, Constants::G_EDIT_FIND);
cmd = createSeparator(am, this, QLatin1String("QtCreator.Edit.Sep.Advanced"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.Edit.Sep.Advanced", m_globalContext);
medit->addAction(cmd, Constants::G_EDIT_ADVANCED);
// Tools menu separators
cmd = createSeparator(am, this, QLatin1String("QtCreator.Tools.Sep.Options"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.Tools.Sep.Options", m_globalContext);
mtools->addAction(cmd, Constants::G_DEFAULT_THREE);
// Help menu separators
@ -653,7 +650,7 @@ void MainWindow::registerDefaultActions()
connect(m_zoomAction, SIGNAL(triggered()), this, SLOT(showMaximized()));
// Window separator
cmd = createSeparator(am, this, QLatin1String("QtCreator.Window.Sep.Size"), m_globalContext);
cmd = createSeparator(am, this, "QtCreator.Window.Sep.Size"), m_globalContext);
mwindow->addAction(cmd, Constants::G_WINDOW_SIZE);
#endif
@ -675,7 +672,7 @@ void MainWindow::registerDefaultActions()
// Window menu separators
QAction *tmpaction1 = new QAction(this);
tmpaction1->setSeparator(true);
cmd = am->registerAction(tmpaction1, QLatin1String("OpenPilot.Window.Sep.Split"), uavGadgetManagerContext);
cmd = am->registerAction(tmpaction1, "OpenPilot.Window.Sep.Split", uavGadgetManagerContext);
mwindow->addAction(cmd, Constants::G_WINDOW_HIDE_TOOLBAR);
m_showToolbarsAction = new QAction(tr("Edit Gadgets Mode"), this);
@ -687,7 +684,7 @@ void MainWindow::registerDefaultActions()
// Window menu separators
QAction *tmpaction2 = new QAction(this);
tmpaction2->setSeparator(true);
cmd = am->registerAction(tmpaction2, QLatin1String("OpenPilot.Window.Sep.Split2"), uavGadgetManagerContext);
cmd = am->registerAction(tmpaction2, "OpenPilot.Window.Sep.Split2", uavGadgetManagerContext);
mwindow->addAction(cmd, Constants::G_WINDOW_SPLIT);
#ifdef Q_WS_MAC
@ -733,7 +730,7 @@ void MainWindow::registerDefaultActions()
#ifndef Q_WS_MAC
tmpaction = new QAction(this);
tmpaction->setSeparator(true);
cmd = am->registerAction(tmpaction, QLatin1String("QtCreator.Help.Sep.About"), m_globalContext);
cmd = am->registerAction(tmpaction, "QtCreator.Help.Sep.About", m_globalContext);
mhelp->addAction(cmd, Constants::G_HELP_ABOUT);
#endif
@ -785,7 +782,8 @@ void MainWindow::saveAll()
}
emit m_coreImpl->saveSettingsRequested();
saveSettings(); // OpenPilot-specific.
QSettings settings;
saveSettings(settings);
}
void MainWindow::exit()
@ -829,15 +827,6 @@ MessageManager *MainWindow::messageManager() const
return m_messageManager;
}
QSettings *MainWindow::settings(QSettings::Scope scope) const
{
if (scope == QSettings::UserScope) {
return m_settings;
} else {
return m_globalSettings;
}
}
VariableManager *MainWindow::variableManager() const
{
return m_variableManager;
@ -1025,7 +1014,7 @@ inline int takeLeastPriorityUavGadgetManager(const QList<Core::UAVGadgetManager
return index;
}
void MainWindow::createWorkspaces(QSettings *qs, bool diffOnly)
void MainWindow::createWorkspaces(QSettings &settings, bool diffOnly)
{
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
@ -1084,175 +1073,161 @@ void MainWindow::createWorkspaces(QSettings *qs, bool diffOnly)
pm->addObject(uavGadgetManager);
m_uavGadgetManagers.append(uavGadgetManager);
uavGadgetManager->readSettings(qs);
uavGadgetManager->readSettings(settings);
qDebug() << "MainWindow::createWorkspaces - creating workspace" << name << "took" << timer.elapsed() << "ms";
}
qDebug() << "MainWindow::createWorkspaces - creating workspaces took" << totalTimer.elapsed() << "ms";
}
static const char *settingsGroup = "MainWindow";
static const char *geometryKey = "Geometry";
static const char *colorKey = "Color";
static const char *maxKey = "Maximized";
static const char *fullScreenKey = "FullScreen";
static const char *modePriorities = "ModePriorities";
static const QString settingsGroup = "MainWindow";
static const QString geometryKey = "Geometry";
static const QString colorKey = "Color";
static const QString maxKey = "Maximized";
static const QString fullScreenKey = "FullScreen";
static const QString modePriorities = "ModePriorities";
void MainWindow::readSettings(QSettings *qs, bool workspaceDiffOnly)
void MainWindow::readSettings(QSettings &settings, bool workspaceDiffOnly)
{
if (!qs) {
qs = m_settings;
}
if (workspaceDiffOnly) {
createWorkspaces(qs, workspaceDiffOnly);
createWorkspaces(settings, workspaceDiffOnly);
return;
}
m_generalSettings->readSettings(qs);
m_actionManager->readSettings(qs);
m_generalSettings->readSettings(settings);
m_actionManager->readSettings(settings);
qs->beginGroup(QLatin1String(settingsGroup));
settings.beginGroup(settingsGroup);
Utils::StyleHelper::setBaseColor(qs->value(QLatin1String(colorKey)).value<QColor>());
Utils::StyleHelper::setBaseColor(settings.value(colorKey).value<QColor>());
const QVariant geom = qs->value(QLatin1String(geometryKey));
const QVariant geom = settings.value(geometryKey);
if (geom.isValid()) {
setGeometry(geom.toRect());
} else {
resize(750, 400);
}
if (qs->value(QLatin1String(maxKey), false).toBool()) {
if (settings.value(maxKey, false).toBool()) {
setWindowState(Qt::WindowMaximized);
}
setFullScreen(qs->value(QLatin1String(fullScreenKey), false).toBool());
setFullScreen(settings.value(fullScreenKey, false).toBool());
qs->endGroup();
settings.endGroup();
m_workspaceSettings->readSettings(qs);
m_workspaceSettings->readSettings(settings);
createWorkspaces(qs);
createWorkspaces(settings);
// Restore tab ordering
qs->beginGroup(QLatin1String(modePriorities));
settings.beginGroup(modePriorities);
QStringList modeNames = qs->childKeys();
QStringList modeNames = settings.childKeys();
QMap<QString, int> map;
foreach(QString modeName, modeNames) {
map.insert(modeName, qs->value(modeName).toInt());
map.insert(modeName, settings.value(modeName).toInt());
}
m_modeManager->reorderModes(map);
qs->endGroup();
settings.endGroup();
// Restore selected tab
if (m_workspaceSettings->restoreSelectedOnStartup()) {
int index = qs->value(QLatin1String("SelectedWorkspace")).toInt();
int index = settings.value("SelectedWorkspace").toInt();
m_modeStack->setCurrentIndex(index);
}
}
void MainWindow::saveSettings(QSettings *qs)
void MainWindow::saveSettings(QSettings &settings) const
{
if (m_dontSaveSettings) {
return;
}
if (!qs) {
qs = m_settings;
}
m_workspaceSettings->saveSettings(settings);
m_workspaceSettings->saveSettings(qs);
settings.beginGroup(settingsGroup);
qs->beginGroup(QLatin1String(settingsGroup));
qs->setValue(QLatin1String(colorKey), Utils::StyleHelper::baseColor());
settings.setValue(colorKey, Utils::StyleHelper::baseColor());
if (windowState() & (Qt::WindowMaximized | Qt::WindowFullScreen)) {
qs->setValue(QLatin1String(maxKey), (bool)(windowState() & Qt::WindowMaximized));
qs->setValue(QLatin1String(fullScreenKey), (bool)(windowState() & Qt::WindowFullScreen));
settings.setValue(maxKey, (bool)(windowState() & Qt::WindowMaximized));
settings.setValue(fullScreenKey, (bool)(windowState() & Qt::WindowFullScreen));
} else {
qs->setValue(QLatin1String(maxKey), false);
qs->setValue(QLatin1String(fullScreenKey), false);
qs->setValue(QLatin1String(geometryKey), geometry());
settings.setValue(maxKey, false);
settings.setValue(fullScreenKey, false);
settings.setValue(geometryKey, geometry());
}
qs->endGroup();
settings.endGroup();
// Write tab ordering
qs->beginGroup(QLatin1String(modePriorities));
settings.beginGroup(modePriorities);
QVector<IMode *> modes = m_modeManager->modes();
foreach(IMode * mode, modes) {
qs->setValue(QLatin1String(mode->uniqueModeName()), mode->priority());
settings.setValue(mode->uniqueModeName(), mode->priority());
}
qs->endGroup();
settings.endGroup();
// Write selected tab
qs->setValue(QLatin1String("SelectedWorkspace"), m_modeStack->currentIndex());
settings.setValue("SelectedWorkspace", m_modeStack->currentIndex());
foreach(UAVGadgetManager * manager, m_uavGadgetManagers) {
manager->saveSettings(qs);
manager->saveSettings(settings);
}
m_actionManager->saveSettings(qs);
m_generalSettings->saveSettings(qs);
m_actionManager->saveSettings(settings);
m_generalSettings->saveSettings(settings);
qs->beginGroup("General");
qs->setValue("Description", m_config_description);
qs->setValue("Details", m_config_details);
qs->setValue("StyleSheet", m_config_stylesheet);
qs->endGroup();
settings.beginGroup("General");
settings.setValue("Description", m_config_description);
settings.setValue("Details", m_config_details);
settings.setValue("StyleSheet", m_config_stylesheet);
settings.endGroup();
}
void MainWindow::readSettings(IConfigurablePlugin *plugin, QSettings *qs)
void MainWindow::readSettings(IConfigurablePlugin *plugin, QSettings &settings)
{
if (!qs) {
qs = m_settings;
}
UAVConfigInfo configInfo;
QObject *qo = reinterpret_cast<QObject *>(plugin);
QString configName = qo->metaObject()->className();
qs->beginGroup("Plugins");
qs->beginGroup(configName);
configInfo.read(qs);
settings.beginGroup("Plugins");
settings.beginGroup(configName);
configInfo.read(settings);
configInfo.setNameOfConfigurable("Plugin-" + configName);
qs->beginGroup("data");
plugin->readConfig(qs, &configInfo);
settings.beginGroup("data");
plugin->readConfig(settings, &configInfo);
qs->endGroup();
qs->endGroup();
qs->endGroup();
settings.endGroup();
settings.endGroup();
settings.endGroup();
}
void MainWindow::saveSettings(IConfigurablePlugin *plugin, QSettings *qs)
void MainWindow::saveSettings(IConfigurablePlugin *plugin, QSettings &settings) const
{
if (m_dontSaveSettings) {
return;
}
if (!qs) {
qs = m_settings;
}
UAVConfigInfo configInfo;
QString configName = plugin->metaObject()->className();
qs->beginGroup("Plugins");
qs->beginGroup(configName);
qs->beginGroup("data");
plugin->saveConfig(qs, &configInfo);
qs->endGroup();
configInfo.save(qs);
qs->endGroup();
qs->endGroup();
settings.beginGroup("Plugins");
settings.beginGroup(configName);
settings.beginGroup("data");
plugin->saveConfig(settings, &configInfo);
settings.endGroup();
configInfo.save(settings);
settings.endGroup();
settings.endGroup();
}
void MainWindow::deleteSettings()
{
m_settings->clear();
m_settings->sync();
QSettings settings;
settings.clear();
settings.sync();
m_dontSaveSettings = true;
}

16
ground/gcs/src/plugins/coreplugin/mainwindow.h
View File

@ -33,8 +33,7 @@
#include "eventfilteringmainwindow.h"
#include <QtCore/QMap>
#include <QSettings>
#include <QMap>
QT_BEGIN_NAMESPACE
class QSettings;
@ -88,10 +87,10 @@ public:
void addContextObject(IContext *contex);
void removeContextObject(IContext *contex);
void resetContext();
void readSettings(QSettings *qs = 0, bool workspaceDiffOnly = false);
void saveSettings(QSettings *qs = 0);
void readSettings(IConfigurablePlugin *plugin, QSettings *qs = 0);
void saveSettings(IConfigurablePlugin *plugin, QSettings *qs = 0);
void readSettings(QSettings &settings, bool workspaceDiffOnly = false);
void saveSettings(QSettings &settings) const;
void readSettings(IConfigurablePlugin *plugin, QSettings &settings);
void saveSettings(IConfigurablePlugin *plugin, QSettings &settings) const;
void deleteSettings();
void openFiles(const QStringList &fileNames);
@ -106,7 +105,6 @@ public:
Core::ModeManager *modeManager() const;
Core::MimeDatabase *mimeDatabase() const;
Internal::GeneralSettings *generalSettings() const;
QSettings *settings(QSettings::Scope scope) const;
inline SettingsDatabase *settingsDatabase() const
{
return m_settingsDatabase;
@ -165,15 +163,13 @@ private:
void updateContextObject(IContext *context);
void registerDefaultContainers();
void registerDefaultActions();
void createWorkspaces(QSettings *qs, bool diffOnly = false);
void createWorkspaces(QSettings &settings, bool diffOnly = false);
QString loadStyleSheet(QString name);
CoreImpl *m_coreImpl;
UniqueIDManager *m_uniqueIDManager;
QList<int> m_globalContext;
QList<int> m_additionalContexts;
QSettings *m_settings;
QSettings *m_globalSettings;
SettingsDatabase *m_settingsDatabase;
bool m_dontSaveSettings; // In case of an Error or if we reset the settings, never save them.
ActionManagerPrivate *m_actionManager;

31
ground/gcs/src/plugins/coreplugin/uavconfiginfo.cpp
View File

@ -48,12 +48,9 @@
Typically a plugin can handle version-changes like this:
\code
MyGadgetConfiguration::MyGadgetConfiguration(QString classId, QSettings* qSettings, UAVConfigInfo *configInfo, QObject *parent) :
MyGadgetConfiguration::MyGadgetConfiguration(QString classId, QSettings &settings, UAVConfigInfo *configInfo, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
if ( ! qSettings )
return;
if ( configInfo->version() == UAVConfigVersion() )
configInfo->setVersion("1.0.0");
@ -63,7 +60,7 @@
... read the config ...
}
void MyGadgetConfiguration::saveConfig(QSettings* qSettings, Core::UAVConfigInfo *configInfo) const {
void MyGadgetConfiguration::saveConfig(QSettings &settings, Core::UAVConfigInfo *configInfo) const {
configInfo->setVersion(CURRENT_VERSION);
@ -118,11 +115,11 @@ UAVConfigInfo::UAVConfigInfo(QObject *parent) :
m_nameOfConfigurable("")
{}
UAVConfigInfo::UAVConfigInfo(QSettings *qs, QObject *parent) :
UAVConfigInfo::UAVConfigInfo(QSettings &settings, QObject *parent) :
QObject(parent),
m_version(VERSION_DEFAULT)
{
read(qs);
read(settings);
}
UAVConfigInfo::UAVConfigInfo(UAVConfigVersion version, QString nameOfConfigurable, QObject *parent) :
@ -139,20 +136,20 @@ UAVConfigInfo::UAVConfigInfo(IUAVGadgetConfiguration *config, QObject *parent) :
m_nameOfConfigurable = config->classId() + "-" + config->name();
}
void UAVConfigInfo::save(QSettings *qs)
void UAVConfigInfo::save(QSettings &settings) const
{
qs->beginGroup("configInfo");
qs->setValue("version", m_version.toString());
qs->setValue("locked", m_locked);
qs->endGroup();
settings.beginGroup("configInfo");
settings.setValue("version", m_version.toString());
settings.setValue("locked", m_locked);
settings.endGroup();
}
void UAVConfigInfo::read(QSettings *qs)
void UAVConfigInfo::read(QSettings &settings)
{
qs->beginGroup("configInfo");
m_version = UAVConfigVersion(qs->value("version", VERSION_DEFAULT).toString());
m_locked = qs->value("locked", false).toBool();
qs->endGroup();
settings.beginGroup("configInfo");
m_version = UAVConfigVersion(settings.value("version", VERSION_DEFAULT).toString());
m_locked = settings.value("locked", false).toBool();
settings.endGroup();
}
bool UAVConfigInfo::askToAbort(int compat, QString message)

12
ground/gcs/src/plugins/coreplugin/uavconfiginfo.h
View File

@ -27,11 +27,12 @@
#ifndef UAVCONFIGINFO_H
#define UAVCONFIGINFO_H
#include "core_global.h"
#include "iuavgadgetconfiguration.h"
#include <QObject>
#include <QString>
#include <QSettings>
#include "iuavgadgetconfiguration.h"
#include "core_global.h"
namespace Core {
class IUAVGadgetConfiguration;
@ -54,18 +55,19 @@ class CORE_EXPORT UAVConfigInfo : public QObject {
public:
explicit UAVConfigInfo(QObject *parent = 0);
explicit UAVConfigInfo(QSettings *qs, QObject *parent = 0);
explicit UAVConfigInfo(QSettings &, QObject *parent = 0);
explicit UAVConfigInfo(IUAVGadgetConfiguration *config, QObject *parent = 0);
UAVConfigInfo(UAVConfigVersion version, QString nameOfConfigurable, QObject *parent = 0);
enum Compatibility { FullyCompatible, MinorLossOfConfiguration, MissingConfiguration, MajorLossOfConfiguration, NotCompatible };
void setNameOfConfigurable(const QString nameOfConfigurable)
{
m_nameOfConfigurable = nameOfConfigurable;
}
void save(QSettings *qs);
void read(QSettings *qs);
void save(QSettings &) const;
void read(QSettings &);
void setVersion(int major, int minor, int patch)
{

25
ground/gcs/src/plugins/coreplugin/uavgadgetdecorator.cpp
View File

@ -26,10 +26,11 @@
*/
#include "uavgadgetdecorator.h"
#include "iuavgadgetconfiguration.h"
#include <QComboBox>
#include <QtCore/QByteArray>
#include <QtCore/QDebug>
#include <QDebug>
using namespace Core;
@ -123,20 +124,20 @@ void UAVGadgetDecorator::updateToolbar()
m_toolbar->setEnabled(m_toolbar->count() > 1);
}
void UAVGadgetDecorator::saveState(QSettings *qSettings)
void UAVGadgetDecorator::saveState(QSettings &settings) const
{
if (m_activeConfiguration) {
qSettings->setValue("activeConfiguration", m_activeConfiguration->name());
settings.setValue("activeConfiguration", m_activeConfiguration->name());
}
// save gadget individual state
qSettings->beginGroup("state");
m_gadget->saveState(qSettings);
qSettings->endGroup();
settings.beginGroup("state");
m_gadget->saveState(settings);
settings.endGroup();
}
void UAVGadgetDecorator::restoreState(QSettings *qSettings)
void UAVGadgetDecorator::restoreState(QSettings &settings)
{
QString configName = qSettings->value("activeConfiguration").toString();
QString configName = settings.value("activeConfiguration").toString();
foreach(IUAVGadgetConfiguration * config, *m_configurations) {
if (config->name() == configName) {
@ -145,7 +146,7 @@ void UAVGadgetDecorator::restoreState(QSettings *qSettings)
}
}
// restore gadget individual state
qSettings->beginGroup("state");
m_gadget->restoreState(qSettings);
qSettings->endGroup();
settings.beginGroup("state");
m_gadget->restoreState(settings);
settings.endGroup();
}

7
ground/gcs/src/plugins/coreplugin/uavgadgetdecorator.h
View File

@ -27,8 +27,11 @@
#ifndef UAVGADGETDECORATOR_H
#define UAVGADGETDECORATOR_H
#include <coreplugin/iuavgadget.h>
class QSettings;
namespace Core {
class IUAVGadgetConfiguration;
@ -51,8 +54,8 @@ public:
return m_activeConfiguration;
}
void loadConfiguration(IUAVGadgetConfiguration *config);
void saveState(QSettings *qSettings);
void restoreState(QSettings *qSettings);
void saveState(QSettings &settings) const;
void restoreState(QSettings &settings);
public slots:
void configurationChanged(IUAVGadgetConfiguration *config);
void configurationAdded(IUAVGadgetConfiguration *config);

127
ground/gcs/src/plugins/coreplugin/uavgadgetinstancemanager.cpp
View File

@ -26,6 +26,7 @@
*/
#include "uavgadgetinstancemanager.h"
#include "iuavgadget.h"
#include "uavgadgetdecorator.h"
#include "iuavgadgetfactory.h"
@ -36,17 +37,16 @@
#include "icore.h"
#include <extensionsystem/pluginmanager.h>
#include <QtCore/QStringList>
#include <QtCore/QSettings>
#include <QtCore/QDebug>
#include <QStringList>
#include <QSettings>
#include <QDebug>
#include <QMessageBox>
using namespace Core;
static const UAVConfigVersion m_versionUAVGadgetConfigurations = UAVConfigVersion("1.2.0");
UAVGadgetInstanceManager::UAVGadgetInstanceManager(QObject *parent) :
QObject(parent)
UAVGadgetInstanceManager::UAVGadgetInstanceManager(QObject *parent) : QObject(parent), m_settingsDialog(NULL)
{
m_pm = ExtensionSystem::PluginManager::instance();
QList<IUAVGadgetFactory *> factories = m_pm->getObjects<IUAVGadgetFactory>();
@ -70,14 +70,17 @@ UAVGadgetInstanceManager::~UAVGadgetInstanceManager()
}
}
void UAVGadgetInstanceManager::readSettings(QSettings *qs)
void UAVGadgetInstanceManager::readSettings(QSettings &settings)
{
while (!m_configurations.isEmpty()) {
emit configurationToBeDeleted(m_configurations.takeLast());
}
qs->beginGroup("UAVGadgetConfigurations");
UAVConfigInfo configInfo(qs);
settings.beginGroup("UAVGadgetConfigurations");
UAVConfigInfo configInfo(settings);
configInfo.setNameOfConfigurable("UAVGadgetConfigurations");
if (configInfo.version() == UAVConfigVersion()) {
// If version is not set, assume its a old version before readable config (1.0.0).
// however compatibility to 1.0.0 is broken.
@ -87,7 +90,7 @@ void UAVGadgetInstanceManager::readSettings(QSettings *qs)
if (configInfo.version() == UAVConfigVersion("1.1.0")) {
configInfo.notify(tr("Migrating UAVGadgetConfigurations from version 1.1.0 to ")
+ m_versionUAVGadgetConfigurations.toString());
readConfigs_1_1_0(qs); // this is fully compatible with 1.2.0
readConfigs_1_1_0(settings); // this is fully compatible with 1.2.0
} else if (!configInfo.standardVersionHandlingOK(m_versionUAVGadgetConfigurations)) {
// We are in trouble now. User wants us to quit the import, but when he saves
// the GCS, his old config will be lost.
@ -95,32 +98,32 @@ void UAVGadgetInstanceManager::readSettings(QSettings *qs)
tr("You might want to save your old config NOW since it might be replaced by broken one when you exit the GCS!")
);
} else {
readConfigs_1_2_0(qs);
readConfigs_1_2_0(settings);
}
qs->endGroup();
settings.endGroup();
createOptionsPages();
}
void UAVGadgetInstanceManager::readConfigs_1_2_0(QSettings *qs)
void UAVGadgetInstanceManager::readConfigs_1_2_0(QSettings &settings)
{
UAVConfigInfo configInfo;
foreach(QString classId, m_classIdNameMap.keys()) {
IUAVGadgetFactory *f = factory(classId);
qs->beginGroup(classId);
settings.beginGroup(classId);
QStringList configs = QStringList();
configs = qs->childGroups();
configs = settings.childGroups();
foreach(QString configName, configs) {
// qDebug() << "Loading config: " << classId << "," << configName;
qs->beginGroup(configName);
configInfo.read(qs);
settings.beginGroup(configName);
configInfo.read(settings);
configInfo.setNameOfConfigurable(classId + "-" + configName);
qs->beginGroup("data");
IUAVGadgetConfiguration *config = f->createConfiguration(qs, &configInfo);
settings.beginGroup("data");
IUAVGadgetConfiguration *config = f->createConfiguration(settings, &configInfo);
if (config) {
config->setName(configName);
config->setProvisionalName(configName);
@ -134,42 +137,42 @@ void UAVGadgetInstanceManager::readConfigs_1_2_0(QSettings *qs)
m_configurations.append(config);
}
}
qs->endGroup();
qs->endGroup();
settings.endGroup();
settings.endGroup();
}
if (configs.count() == 0) {
IUAVGadgetConfiguration *config = f->createConfiguration(0, 0);
// it is not mandatory for uavgadgets to have any configurations (settings)
// and therefore we have to check for that
if (config) {
config->setName(tr("default"));
config->setProvisionalName(tr("default"));
m_configurations.append(config);
}
}
qs->endGroup();
// if (configs.count() == 0) {
// IUAVGadgetConfiguration *config = f->createConfiguration(0, 0);
//// it is not mandatory for uavgadgets to have any configurations (settings)
//// and therefore we have to check for that
// if (config) {
// config->setName(tr("default"));
// config->setProvisionalName(tr("default"));
// m_configurations.append(config);
// }
// }
settings.endGroup();
}
}
void UAVGadgetInstanceManager::readConfigs_1_1_0(QSettings *qs)
void UAVGadgetInstanceManager::readConfigs_1_1_0(QSettings &settings)
{
UAVConfigInfo configInfo;
foreach(QString classId, m_classIdNameMap.keys()) {
IUAVGadgetFactory *f = factory(classId);
qs->beginGroup(classId);
settings.beginGroup(classId);
QStringList configs = QStringList();
configs = qs->childGroups();
configs = settings.childGroups();
foreach(QString configName, configs) {
// qDebug().nospace() << "Loading config: " << classId << ", " << configName;
qs->beginGroup(configName);
bool locked = qs->value("config.locked").toBool();
settings.beginGroup(configName);
bool locked = settings.value("config.locked").toBool();
configInfo.setNameOfConfigurable(classId + "-" + configName);
IUAVGadgetConfiguration *config = f->createConfiguration(qs, &configInfo);
IUAVGadgetConfiguration *config = f->createConfiguration(settings, &configInfo);
if (config) {
config->setName(configName);
config->setProvisionalName(configName);
@ -183,45 +186,45 @@ void UAVGadgetInstanceManager::readConfigs_1_1_0(QSettings *qs)
m_configurations.append(config);
}
}
qs->endGroup();
settings.endGroup();
}
if (configs.count() == 0) {
IUAVGadgetConfiguration *config = f->createConfiguration(0, 0);
// it is not mandatory for uavgadgets to have any configurations (settings)
// and therefore we have to check for that
if (config) {
config->setName(tr("default"));
config->setProvisionalName(tr("default"));
m_configurations.append(config);
}
}
qs->endGroup();
// if (configs.count() == 0) {
// IUAVGadgetConfiguration *config = f->createConfiguration(0, 0);
//// it is not mandatory for uavgadgets to have any configurations (settings)
//// and therefore we have to check for that
// if (config) {
// config->setName(tr("default"));
// config->setProvisionalName(tr("default"));
// m_configurations.append(config);
// }
// }
settings.endGroup();
}
}
void UAVGadgetInstanceManager::saveSettings(QSettings *qs)
void UAVGadgetInstanceManager::saveSettings(QSettings &settings) const
{
UAVConfigInfo *configInfo;
qs->beginGroup("UAVGadgetConfigurations");
qs->remove(""); // Remove existing configurations
settings.beginGroup("UAVGadgetConfigurations");
settings.remove(""); // Remove existing configurations
configInfo = new UAVConfigInfo(m_versionUAVGadgetConfigurations, "UAVGadgetConfigurations");
configInfo->save(qs);
configInfo->save(settings);
delete configInfo;
foreach(IUAVGadgetConfiguration * config, m_configurations) {
configInfo = new UAVConfigInfo(config);
qs->beginGroup(config->classId());
qs->beginGroup(config->name());
qs->beginGroup("data");
config->saveConfig(qs, configInfo);
qs->endGroup();
configInfo->save(qs);
qs->endGroup();
qs->endGroup();
settings.beginGroup(config->classId());
settings.beginGroup(config->name());
settings.beginGroup("data");
config->saveConfig(settings, configInfo);
settings.endGroup();
configInfo->save(settings);
settings.endGroup();
settings.endGroup();
delete configInfo;
}
qs->endGroup();
settings.endGroup();
}
void UAVGadgetInstanceManager::createOptionsPages()

19
ground/gcs/src/plugins/coreplugin/uavgadgetinstancemanager.h
View File

@ -28,14 +28,15 @@
#ifndef UAVGADGETINSTANCEMANAGER_H
#define UAVGADGETINSTANCEMANAGER_H
#include <QObject>
#include <QSettings>
#include <QtCore/QMap>
#include <QtCore/QStringList>
#include <QIcon>
#include "core_global.h"
#include "uavconfiginfo.h"
#include <QObject>
#include <QSettings>
#include <QMap>
#include <QStringList>
#include <QIcon>
namespace ExtensionSystem {
class PluginManager;
}
@ -58,8 +59,8 @@ public:
explicit UAVGadgetInstanceManager(QObject *parent = 0);
~UAVGadgetInstanceManager();
void readSettings(QSettings *qs);
void saveSettings(QSettings *qs);
void readSettings(QSettings &settings);
void saveSettings(QSettings &settings) const;
IUAVGadget *createGadget(QString classId, QWidget *parent, bool loadDefaultConfiguration = true);
void removeGadget(IUAVGadget *gadget);
@ -116,8 +117,8 @@ private:
int indexForConfig(QList<IUAVGadgetConfiguration *> configurations, QString classId, QString configName);
void readConfigs_1_1_0(QSettings *qs);
void readConfigs_1_2_0(QSettings *qs);
void readConfigs_1_1_0(QSettings &settings);
void readConfigs_1_2_0(QSettings &settings);
};
} // namespace Core

48
ground/gcs/src/plugins/coreplugin/uavgadgetmanager/splitterorview.cpp
View File

@ -32,7 +32,9 @@
#include "iuavgadget.h"
#include "minisplitter.h"
#include <QtCore/QDebug>
#include <QStackedLayout>
#include <QSettings>
#include <QDebug>
#ifdef Q_WS_MAC
#include <qmacstyle_mac.h>
@ -382,47 +384,47 @@ void SplitterOrView::unsplitAll_helper(UAVGadgetManager *uavGadgetManager, QSpli
}
}
void SplitterOrView::saveState(QSettings *qSettings) const
void SplitterOrView::saveState(QSettings &settings) const
{
if (m_splitter) {
qSettings->setValue("type", "splitter");
qSettings->setValue("splitterOrientation", (qint32)m_splitter->orientation());
settings.setValue("type", "splitter");
settings.setValue("splitterOrientation", (qint32)m_splitter->orientation());
QList<QVariant> sizesQVariant;
foreach(int value, m_sizes) {
sizesQVariant.append(value);
}
qSettings->setValue("splitterSizes", sizesQVariant);
qSettings->beginGroup("side0");
static_cast<SplitterOrView *>(m_splitter->widget(0))->saveState(qSettings);
qSettings->endGroup();
qSettings->beginGroup("side1");
static_cast<SplitterOrView *>(m_splitter->widget(1))->saveState(qSettings);
qSettings->endGroup();
settings.setValue("splitterSizes", sizesQVariant);
settings.beginGroup("side0");
static_cast<SplitterOrView *>(m_splitter->widget(0))->saveState(settings);
settings.endGroup();
settings.beginGroup("side1");
static_cast<SplitterOrView *>(m_splitter->widget(1))->saveState(settings);
settings.endGroup();
} else if (gadget()) {
m_view->saveState(qSettings);
m_view->saveState(settings);
}
}
void SplitterOrView::restoreState(QSettings *qSettings)
void SplitterOrView::restoreState(QSettings &settings)
{
QString mode = qSettings->value("type").toString();
QString mode = settings.value("type").toString();
if (mode == "splitter") {
qint32 orientation = qSettings->value("splitterOrientation").toInt();
QList<QVariant> sizesQVariant = qSettings->value("splitterSizes").toList();
qint32 orientation = settings.value("splitterOrientation").toInt();
QList<QVariant> sizesQVariant = settings.value("splitterSizes").toList();
m_sizes.clear();
foreach(QVariant value, sizesQVariant) {
m_sizes.append(value.toInt());
}
split((Qt::Orientation)orientation);
m_splitter->setSizes(m_sizes);
qSettings->beginGroup("side0");
static_cast<SplitterOrView *>(m_splitter->widget(0))->restoreState(qSettings);
qSettings->endGroup();
qSettings->beginGroup("side1");
static_cast<SplitterOrView *>(m_splitter->widget(1))->restoreState(qSettings);
qSettings->endGroup();
settings.beginGroup("side0");
static_cast<SplitterOrView *>(m_splitter->widget(0))->restoreState(settings);
settings.endGroup();
settings.beginGroup("side1");
static_cast<SplitterOrView *>(m_splitter->widget(1))->restoreState(settings);
settings.endGroup();
} else if (mode == "uavGadget") {
m_view->restoreState(qSettings);
m_view->restoreState(settings);
}
}

12
ground/gcs/src/plugins/coreplugin/uavgadgetmanager/splitterorview.h
View File

@ -29,11 +29,15 @@
#ifndef SPLITTERORVIEW_H
#define SPLITTERORVIEW_H
#include <QWidget>
#include <QMouseEvent>
#include "uavgadgetmanager.h"
#include "uavgadgetview.h"
#include <QWidget>
#include <QMouseEvent>
#include <QSplitter>
class QSettings;
namespace Core {
namespace Internal {
class SplitterOrView : public QWidget {
@ -82,8 +86,8 @@ public:
QSplitter *takeSplitter();
UAVGadgetView *takeView();
void saveState(QSettings *) const;
void restoreState(QSettings *);
void saveState(QSettings &) const;
void restoreState(QSettings &);
SplitterOrView *findView(Core::IUAVGadget *uavGadget);
SplitterOrView *findView(UAVGadgetView *view);

78
ground/gcs/src/plugins/coreplugin/uavgadgetmanager/uavgadgetmanager.cpp
View File

@ -27,6 +27,7 @@
*/
#include "uavgadgetmanager.h"
#include "uavgadgetview.h"
#include "splitterorview.h"
#include "uavgadgetinstancemanager.h"
@ -37,31 +38,16 @@
#include <coreplugin/coreconstants.h>
#include <coreplugin/modemanager.h>
#include <coreplugin/uniqueidmanager.h>
#include <coreplugin/actionmanager/actionmanager.h>
#include <coreplugin/baseview.h>
#include <coreplugin/imode.h>
#include <coreplugin/settingsdatabase.h>
#include <coreplugin/variablemanager.h>
#include <extensionsystem/pluginmanager.h>
#include <utils/consoleprocess.h>
#include <utils/qtcassert.h>
#include <QtCore/QDebug>
#include <QtCore/QMap>
#include <QtCore/QProcess>
#include <QtCore/QSet>
#include <QAction>
#include <QtWidgets/QApplication>
#include <QLayout>
#include <QMainWindow>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>
#include <QSplitter>
#include <QStackedLayout>
#include <QDebug>
#include <QApplication>
#include <QHBoxLayout>
Q_DECLARE_METATYPE(Core::IUAVGadget *)
@ -291,16 +277,16 @@ void UAVGadgetManager::updateUavGadgetMenus()
emit showUavGadgetMenus(m_showToolbars, hasSplitter);
}
void UAVGadgetManager::saveState(QSettings *qSettings) const
void UAVGadgetManager::saveState(QSettings &settings) const
{
qSettings->setValue("version", "UAVGadgetManagerV1");
qSettings->setValue("showToolbars", m_showToolbars);
qSettings->beginGroup("splitter");
m_splitterOrView->saveState(qSettings);
qSettings->endGroup();
settings.setValue("version", "UAVGadgetManagerV1");
settings.setValue("showToolbars", m_showToolbars);
settings.beginGroup("splitter");
m_splitterOrView->saveState(settings);
settings.endGroup();
}
bool UAVGadgetManager::restoreState(QSettings *qSettings)
bool UAVGadgetManager::restoreState(QSettings &settings)
{
removeAllSplits();
@ -309,59 +295,59 @@ bool UAVGadgetManager::restoreState(QSettings *qSettings)
emptyView(m_splitterOrView->view());
im->removeGadget(gadget);
QString version = qSettings->value("version").toString();
QString version = settings.value("version").toString();
if (version != "UAVGadgetManagerV1") {
return false;
}
m_showToolbars = qSettings->value("showToolbars").toBool();
m_showToolbars = settings.value("showToolbars").toBool();
QApplication::setOverrideCursor(Qt::WaitCursor);
qSettings->beginGroup("splitter");
m_splitterOrView->restoreState(qSettings);
qSettings->endGroup();
settings.beginGroup("splitter");
m_splitterOrView->restoreState(settings);
settings.endGroup();
QApplication::restoreOverrideCursor();
return true;
}
void UAVGadgetManager::saveSettings(QSettings *qs)
void UAVGadgetManager::saveSettings(QSettings &settings) const
{
qs->beginGroup("UAVGadgetManager");
qs->beginGroup(this->uniqueModeName());
settings.beginGroup("UAVGadgetManager");
settings.beginGroup(this->uniqueModeName());
// Make sure the old tree is wiped.
qs->remove("");
settings.remove("");
// Do actual saving
saveState(qs);
saveState(settings);
qs->endGroup();
qs->endGroup();
settings.endGroup();
settings.endGroup();
}
void UAVGadgetManager::readSettings(QSettings *qs)
void UAVGadgetManager::readSettings(QSettings &settings)
{
QString uavGadgetManagerRootKey = "UAVGadgetManager";
if (!qs->childGroups().contains(uavGadgetManagerRootKey)) {
if (!settings.childGroups().contains(uavGadgetManagerRootKey)) {
return;
}
qs->beginGroup(uavGadgetManagerRootKey);
settings.beginGroup(uavGadgetManagerRootKey);
if (!qs->childGroups().contains(uniqueModeName())) {
qs->endGroup();
if (!settings.childGroups().contains(uniqueModeName())) {
settings.endGroup();
return;
}
qs->beginGroup(uniqueModeName());
settings.beginGroup(uniqueModeName());
restoreState(qs);
restoreState(settings);
showToolbars(m_showToolbars);
qs->endGroup();
qs->endGroup();
settings.endGroup();
settings.endGroup();
}
void UAVGadgetManager::split(Qt::Orientation orientation)

14
ground/gcs/src/plugins/coreplugin/uavgadgetmanager/uavgadgetmanager.h
View File

@ -35,13 +35,12 @@
#include <coreplugin/imode.h>
#include <QWidget>
#include <QtCore/QList>
#include <QtCore/QPointer>
#include <QtCore/QSettings>
#include <QList>
#include <QIcon>
QT_BEGIN_NAMESPACE
class QModelIndex;
class QSettings;
QT_END_NAMESPACE
namespace Core {
@ -95,11 +94,12 @@ public:
IUAVGadget *currentGadget() const;
void saveState(QSettings *) const;
bool restoreState(QSettings *qSettings);
void saveState(QSettings &) const;
bool restoreState(QSettings &);
void readSettings(QSettings &settings);
void saveSettings(QSettings &settings) const;
void saveSettings(QSettings *qs);
void readSettings(QSettings *qs);
bool toolbarsShown()
{
return m_showToolbars;

24
ground/gcs/src/plugins/coreplugin/uavgadgetmanager/uavgadgetview.cpp
View File

@ -261,18 +261,18 @@ void UAVGadgetView::currentGadgetChanged(IUAVGadget *gadget)
m_activeLabel->setVisible(m_uavGadget == gadget);
}
void UAVGadgetView::saveState(QSettings *qSettings)
void UAVGadgetView::saveState(QSettings &settings) const
{
qSettings->setValue("type", "uavGadget");
qSettings->setValue("classId", gadget()->classId());
qSettings->beginGroup("gadget");
gadget()->saveState(qSettings);
qSettings->endGroup();
settings.setValue("type", "uavGadget");
settings.setValue("classId", gadget()->classId());
settings.beginGroup("gadget");
gadget()->saveState(settings);
settings.endGroup();
}
void UAVGadgetView::restoreState(QSettings *qSettings)
void UAVGadgetView::restoreState(QSettings &settings)
{
QString classId = qSettings->value("classId").toString();
QString classId = settings.value("classId").toString();
int index = indexOfClassId(classId);
if (index < 0) {
@ -282,11 +282,11 @@ void UAVGadgetView::restoreState(QSettings *qSettings)
IUAVGadget *newGadget;
UAVGadgetInstanceManager *im = ICore::instance()->uavGadgetInstanceManager();
if (qSettings->childGroups().contains("gadget")) {
if (settings.childGroups().contains("gadget")) {
newGadget = im->createGadget(classId, this, false);
qSettings->beginGroup("gadget");
newGadget->restoreState(qSettings);
qSettings->endGroup();
settings.beginGroup("gadget");
newGadget->restoreState(settings);
settings.endGroup();
} else {
newGadget = im->createGadget(classId, this);
}

17
ground/gcs/src/plugins/coreplugin/uavgadgetmanager/uavgadgetview.h
View File

@ -29,22 +29,17 @@
#ifndef UAVGADGETVIEW_H
#define UAVGADGETVIEW_H
#include <QtCore/QList>
#include <QtCore/QString>
#include <QtCore/QSettings>
#include <QList>
#include <QString>
#include <QWidget>
#include <QAction>
#include <QSplitter>
#include <QVBoxLayout>
#include <QStackedLayout>
#include <QtCore/QPointer>
#include <QPointer>
QT_BEGIN_NAMESPACE
class QComboBox;
class QToolButton;
class QLabel;
class QVBoxLayout;
class QSettings;
QT_END_NAMESPACE
namespace Utils {
@ -70,8 +65,8 @@ public:
void showToolbar(bool show);
void saveState(QSettings *qSettings);
void restoreState(QSettings *qSettings);
void saveState(QSettings &settings) const;
void restoreState(QSettings &settings);
public slots:
void closeView();

45
ground/gcs/src/plugins/coreplugin/workspacesettings.cpp
View File

@ -26,13 +26,15 @@
*/
#include "workspacesettings.h"
#include <coreplugin/icore.h>
#include <coreplugin/modemanager.h>
#include <coreplugin/uavgadgetmanager/uavgadgetmanager.h>
#include <QtCore/QSettings>
#include "ui_workspacesettings.h"
#include <QSettings>
using namespace Core;
using namespace Core::Internal;
@ -100,62 +102,63 @@ QWidget *WorkspaceSettings::createPage(QWidget *parent)
return w;
}
void WorkspaceSettings::readSettings(QSettings *qs)
void WorkspaceSettings::readSettings(QSettings &settings)
{
m_names.clear();
m_iconNames.clear();
m_modeNames.clear();
qs->beginGroup(QLatin1String("Workspace"));
m_numberOfWorkspaces = qs->value(QLatin1String("NumberOfWorkspaces"), 2).toInt();
settings.beginGroup(QLatin1String("Workspace"));
m_numberOfWorkspaces = settings.value(QLatin1String("NumberOfWorkspaces"), 2).toInt();
m_previousNumberOfWorkspaces = m_numberOfWorkspaces;
for (int i = 1; i <= MAX_WORKSPACES; ++i) {
QString numberString = QString::number(i);
QString defaultName = "Workspace" + numberString;
QString defaultIconName = "Icon" + numberString;
QString name = qs->value(defaultName, defaultName).toString();
QString iconName = qs->value(defaultIconName, ":/core/images/librepilot_logo_64.png").toString();
QString name = settings.value(defaultName, defaultName).toString();
QString iconName = settings.value(defaultIconName, ":/core/images/librepilot_logo_64.png").toString();
m_names.append(name);
m_iconNames.append(iconName);
m_modeNames.append(QString("Mode") + QString::number(i));
}
m_tabBarPlacementIndex = qs->value(QLatin1String("TabBarPlacementIndex"), 1).toInt(); // 1 == "Bottom"
m_allowTabBarMovement = qs->value(QLatin1String("AllowTabBarMovement"), false).toBool();
m_restoreSelectedOnStartup = qs->value(QLatin1String("RestoreSelectedOnStartup"), false).toBool();
m_tabBarPlacementIndex = settings.value(QLatin1String("TabBarPlacementIndex"), 1).toInt(); // 1 == "Bottom"
m_allowTabBarMovement = settings.value(QLatin1String("AllowTabBarMovement"), false).toBool();
m_restoreSelectedOnStartup = settings.value(QLatin1String("RestoreSelectedOnStartup"), false).toBool();
qs->endGroup();
settings.endGroup();
QTabWidget::TabPosition pos = m_tabBarPlacementIndex == 0 ? QTabWidget::North : QTabWidget::South;
emit tabBarSettingsApplied(pos, m_allowTabBarMovement);
}
void WorkspaceSettings::saveSettings(QSettings *qs)
void WorkspaceSettings::saveSettings(QSettings &settings) const
{
qs->beginGroup(QLatin1String("Workspace"));
qs->setValue(QLatin1String("NumberOfWorkspaces"), m_numberOfWorkspaces);
settings.beginGroup(QLatin1String("Workspace"));
settings.setValue(QLatin1String("NumberOfWorkspaces"), m_numberOfWorkspaces);
for (int i = 0; i < MAX_WORKSPACES; ++i) {
QString mode = QString("Mode") + QString::number(i + 1);
int j = m_modeNames.indexOf(mode);
QString numberString = QString::number(i + 1);
QString defaultName = "Workspace" + numberString;
QString defaultIconName = "Icon" + numberString;
qs->setValue(defaultName, m_names.at(j));
qs->setValue(defaultIconName, m_iconNames.at(j));
settings.setValue(defaultName, m_names.at(j));
settings.setValue(defaultIconName, m_iconNames.at(j));
}
qs->setValue(QLatin1String("TabBarPlacementIndex"), m_tabBarPlacementIndex);
qs->setValue(QLatin1String("AllowTabBarMovement"), m_allowTabBarMovement);
qs->setValue(QLatin1String("RestoreSelectedOnStartup"), m_restoreSelectedOnStartup);
qs->endGroup();
settings.setValue(QLatin1String("TabBarPlacementIndex"), m_tabBarPlacementIndex);
settings.setValue(QLatin1String("AllowTabBarMovement"), m_allowTabBarMovement);
settings.setValue(QLatin1String("RestoreSelectedOnStartup"), m_restoreSelectedOnStartup);
settings.endGroup();
}
void WorkspaceSettings::apply()
{
selectWorkspace(m_currentIndex, true);
saveSettings(Core::ICore::instance()->settings());
QSettings settings;
saveSettings(settings);
if (m_numberOfWorkspaces != m_previousNumberOfWorkspaces) {
Core::ICore::instance()->readMainSettings(Core::ICore::instance()->settings(), true);
Core::ICore::instance()->readMainSettings(settings, true);
m_previousNumberOfWorkspaces = m_numberOfWorkspaces;
}

9
ground/gcs/src/plugins/coreplugin/workspacesettings.h
View File

@ -29,8 +29,9 @@
#define WORKSPACESETTINGS_H
#include <coreplugin/dialogs/ioptionspage.h>
#include <QtCore/QObject>
#include <QtCore/QStringList>
#include <QObject>
#include <QStringList>
#include <QTabWidget>
class QSettings;
@ -59,8 +60,8 @@ public:
QWidget *createPage(QWidget *parent);
void apply();
void finish();
void readSettings(QSettings *qs);
void saveSettings(QSettings *qs);
void readSettings(QSettings &settings);
void saveSettings(QSettings &settings) const;
int numberOfWorkspaces() const
{
return m_numberOfWorkspaces;

207
ground/gcs/src/plugins/dial/dialgadgetconfiguration.cpp
View File

@ -30,146 +30,125 @@
#include "utils/pathutils.h"
/**
* Loads a saved configuration or defaults if non exist.
* Loads a saved configuration.
*
*/
DialGadgetConfiguration::DialGadgetConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent),
m_defaultDial("Unknown"),
dialBackgroundID("background"),
dialForegroundID("foreground"),
dialNeedleID1("needle"),
dialNeedleID2("needle2"),
dialNeedleID3("needle3"),
needle1MinValue(0),
needle1MaxValue(100),
needle2MinValue(0),
needle2MaxValue(100),
needle3MinValue(0),
needle3MaxValue(100),
needle1Factor(1),
needle2Factor(1),
needle3Factor(1),
needle1Move("Rotate"),
needle2Move("Rotate"),
needle3Move("Rotate"),
useOpenGLFlag(false),
beSmooth(true)
DialGadgetConfiguration::DialGadgetConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
// if a saved configuration exists load it
if (qSettings != 0) {
QString dialFile = qSettings->value("dialFile").toString();
QString dialFile = settings.value("dialFile", "Unknown").toString();
m_defaultDial = Utils::InsertDataPath(dialFile);
dialBackgroundID = qSettings->value("dialBackgroundID").toString();
dialForegroundID = qSettings->value("dialForegroundID").toString();
dialNeedleID1 = qSettings->value("dialNeedleID1").toString();
dialNeedleID2 = qSettings->value("dialNeedleID2").toString();
dialNeedleID3 = qSettings->value("dialNeedleID3").toString();
needle1MinValue = qSettings->value("needle1MinValue").toDouble();
needle1MaxValue = qSettings->value("needle1MaxValue").toDouble();
needle2MinValue = qSettings->value("needle2MinValue").toDouble();
needle2MaxValue = qSettings->value("needle2MaxValue").toDouble();
needle3MinValue = qSettings->value("needle3MinValue").toDouble();
needle3MaxValue = qSettings->value("needle3MaxValue").toDouble();
needle1DataObject = qSettings->value("needle1DataObject").toString();
needle1ObjectField = qSettings->value("needle1ObjectField").toString();
needle2DataObject = qSettings->value("needle2DataObject").toString();
needle2ObjectField = qSettings->value("needle2ObjectField").toString();
needle3DataObject = qSettings->value("needle3DataObject").toString();
needle3ObjectField = qSettings->value("needle3ObjectField").toString();
needle1Factor = qSettings->value("needle1Factor").toDouble();
needle2Factor = qSettings->value("needle2Factor").toDouble();
needle3Factor = qSettings->value("needle3Factor").toDouble();
needle1Move = qSettings->value("needle1Move").toString();
needle2Move = qSettings->value("needle2Move").toString();
needle3Move = qSettings->value("needle3Move").toString();
font = qSettings->value("font").toString();
useOpenGLFlag = qSettings->value("useOpenGLFlag").toBool();
beSmooth = qSettings->value("beSmooth").toBool();
}
m_defaultDial = Utils::InsertDataPath(dialFile);
dialBackgroundID = settings.value("dialBackgroundID", "background").toString();
dialForegroundID = settings.value("dialForegroundID", "foreground").toString();
dialNeedleID1 = settings.value("dialNeedleID1", "needle").toString();
dialNeedleID2 = settings.value("dialNeedleID2", "needle2").toString();
dialNeedleID3 = settings.value("dialNeedleID3", "needle3").toString();
needle1MinValue = settings.value("needle1MinValue", 0).toDouble();
needle1MaxValue = settings.value("needle1MaxValue", 100).toDouble();
needle2MinValue = settings.value("needle2MinValue", 0).toDouble();
needle2MaxValue = settings.value("needle2MaxValue", 100).toDouble();
needle3MinValue = settings.value("needle3MinValue", 0).toDouble();
needle3MaxValue = settings.value("needle3MaxValue", 100).toDouble();
needle1DataObject = settings.value("needle1DataObject").toString();
needle1ObjectField = settings.value("needle1ObjectField").toString();
needle2DataObject = settings.value("needle2DataObject").toString();
needle2ObjectField = settings.value("needle2ObjectField").toString();
needle3DataObject = settings.value("needle3DataObject").toString();
needle3ObjectField = settings.value("needle3ObjectField").toString();
needle1Factor = settings.value("needle1Factor", 1).toDouble();
needle2Factor = settings.value("needle2Factor", 1).toDouble();
needle3Factor = settings.value("needle3Factor", 1).toDouble();
needle1Move = settings.value("needle1Move", "Rotate").toString();
needle2Move = settings.value("needle2Move", "Rotate").toString();
needle3Move = settings.value("needle3Move", "Rotate").toString();
font = settings.value("font").toString();
useOpenGLFlag = settings.value("useOpenGLFlag", false).toBool();
beSmooth = settings.value("beSmooth", true).toBool();
}
DialGadgetConfiguration::DialGadgetConfiguration(const DialGadgetConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
m_defaultDial = obj.m_defaultDial;
dialBackgroundID = obj.dialBackgroundID;
dialForegroundID = obj.dialForegroundID;
dialNeedleID1 = obj.dialNeedleID1;
dialNeedleID2 = obj.dialNeedleID2;
dialNeedleID3 = obj.dialNeedleID3;
needle1MinValue = obj.needle1MinValue;
needle1MaxValue = obj.needle1MaxValue;
needle2MinValue = obj.needle2MinValue;
needle2MaxValue = obj.needle2MaxValue;
needle3MinValue = obj.needle3MinValue;
needle3MaxValue = obj.needle3MaxValue;
needle1DataObject = obj.needle1DataObject;
needle1ObjectField = obj.needle1ObjectField;
needle2DataObject = obj.needle2DataObject;
needle2ObjectField = obj.needle2ObjectField;
needle3DataObject = obj.needle3DataObject;
needle3ObjectField = obj.needle3ObjectField;
needle1Factor = obj.needle1Factor;
needle2Factor = obj.needle2Factor;
needle3Factor = obj.needle3Factor;
needle1Move = obj.needle1Move;
needle2Move = obj.needle2Move;
needle3Move = obj.needle3Move;
font = obj.font;
useOpenGLFlag = obj.useOpenGLFlag;
beSmooth = obj.beSmooth;
}
/**
* Clones a configuration.
*
*/
IUAVGadgetConfiguration *DialGadgetConfiguration::clone()
IUAVGadgetConfiguration *DialGadgetConfiguration::clone() const
{
DialGadgetConfiguration *m = new DialGadgetConfiguration(this->classId());
m->m_defaultDial = m_defaultDial;
m->setDialBackgroundID(dialBackgroundID);
m->setDialForegroundID(dialForegroundID);
m->setDialNeedleID1(dialNeedleID1);
m->setDialNeedleID2(dialNeedleID2);
m->setDialNeedleID3(dialNeedleID3);
m->setN1Min(needle1MinValue);
m->setN1Max(needle1MaxValue);
m->setN2Min(needle2MinValue);
m->setN2Max(needle2MaxValue);
m->setN3Min(needle3MinValue);
m->setN3Max(needle3MaxValue);
m->setN1DataObject(needle1DataObject);
m->setN1ObjField(needle1ObjectField);
m->setN2DataObject(needle2DataObject);
m->setN2ObjField(needle2ObjectField);
m->setN3DataObject(needle3DataObject);
m->setN3ObjField(needle3ObjectField);
m->setN1Factor(needle1Factor);
m->setN2Factor(needle2Factor);
m->setN3Factor(needle3Factor);
m->setN1Move(needle1Move);
m->setN2Move(needle2Move);
m->setN3Move(needle3Move);
m->setFont(font);
m->useOpenGLFlag = useOpenGLFlag;
m->beSmooth = beSmooth;
return m;
return new DialGadgetConfiguration(*this);
}
/**
* Saves a configuration.
*
*/
void DialGadgetConfiguration::saveConfig(QSettings *settings) const
void DialGadgetConfiguration::saveConfig(QSettings &settings) const
{
QString dialFile = Utils::RemoveDataPath(m_defaultDial);
settings->setValue("dialFile", dialFile);
settings.setValue("dialFile", dialFile);
settings->setValue("dialBackgroundID", dialBackgroundID);
settings->setValue("dialForegroundID", dialForegroundID);
settings.setValue("dialBackgroundID", dialBackgroundID);
settings.setValue("dialForegroundID", dialForegroundID);
settings->setValue("dialNeedleID1", dialNeedleID1);
settings->setValue("dialNeedleID2", dialNeedleID2);
settings->setValue("dialNeedleID3", dialNeedleID3);
settings.setValue("dialNeedleID1", dialNeedleID1);
settings.setValue("dialNeedleID2", dialNeedleID2);
settings.setValue("dialNeedleID3", dialNeedleID3);
settings->setValue("needle1MinValue", needle1MinValue);
settings->setValue("needle1MaxValue", needle1MaxValue);
settings->setValue("needle2MinValue", needle2MinValue);
settings->setValue("needle2MaxValue", needle2MaxValue);
settings->setValue("needle3MinValue", needle3MinValue);
settings->setValue("needle3MaxValue", needle3MaxValue);
settings.setValue("needle1MinValue", QString::number(needle1MinValue));
settings.setValue("needle1MaxValue", QString::number(needle1MaxValue));
settings.setValue("needle2MinValue", QString::number(needle2MinValue));
settings.setValue("needle2MaxValue", QString::number(needle2MaxValue));
settings.setValue("needle3MinValue", QString::number(needle3MinValue));
settings.setValue("needle3MaxValue", QString::number(needle3MaxValue));
settings->setValue("needle1DataObject", needle1DataObject);
settings->setValue("needle1ObjectField", needle1ObjectField);
settings->setValue("needle2DataObject", needle2DataObject);
settings->setValue("needle2ObjectField", needle2ObjectField);
settings->setValue("needle3DataObject", needle3DataObject);
settings->setValue("needle3ObjectField", needle3ObjectField);
settings.setValue("needle1DataObject", needle1DataObject);
settings.setValue("needle1ObjectField", needle1ObjectField);
settings.setValue("needle2DataObject", needle2DataObject);
settings.setValue("needle2ObjectField", needle2ObjectField);
settings.setValue("needle3DataObject", needle3DataObject);
settings.setValue("needle3ObjectField", needle3ObjectField);
settings->setValue("needle1Factor", needle1Factor);
settings->setValue("needle2Factor", needle2Factor);
settings->setValue("needle3Factor", needle3Factor);
settings.setValue("needle1Factor", QString::number(needle1Factor));
settings.setValue("needle2Factor", QString::number(needle2Factor));
settings.setValue("needle3Factor", QString::number(needle3Factor));
settings->setValue("needle1Move", needle1Move);
settings->setValue("needle2Move", needle2Move);
settings->setValue("needle3Move", needle3Move);
settings.setValue("needle1Move", needle1Move);
settings.setValue("needle2Move", needle2Move);
settings.setValue("needle3Move", needle3Move);
settings->setValue("font", font);
settings.setValue("font", font);
settings->setValue("useOpenGLFlag", useOpenGLFlag);
settings->setValue("beSmooth", beSmooth);
settings.setValue("useOpenGLFlag", useOpenGLFlag);
settings.setValue("beSmooth", beSmooth);
}

9
ground/gcs/src/plugins/dial/dialgadgetconfiguration.h
View File

@ -39,8 +39,11 @@ using namespace Core;
class DialGadgetConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT
public:
explicit DialGadgetConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit DialGadgetConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit DialGadgetConfiguration(const DialGadgetConfiguration &obj);
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
// set dial configuration functions
void setDialFile(QString dialFile)
@ -152,7 +155,6 @@ public:
beSmooth = flag;
}
// get dial configuration functions
QString dialFile()
{
@ -263,9 +265,6 @@ public:
return beSmooth;
}
void saveConfig(QSettings *settings) const;
IUAVGadgetConfiguration *clone();
private:
QString m_defaultDial; // The name of the dial's SVG source file
QString dialBackgroundID; // SVG elementID of the background

4
ground/gcs/src/plugins/dial/dialgadgetfactory.cpp
View File

@ -48,9 +48,9 @@ Core::IUAVGadget *DialGadgetFactory::createGadget(QWidget *parent)
return new DialGadget(QString("DialGadget"), gadgetWidget, parent);
}
IUAVGadgetConfiguration *DialGadgetFactory::createConfiguration(QSettings *qSettings)
IUAVGadgetConfiguration *DialGadgetFactory::createConfiguration(QSettings &settings)
{
return new DialGadgetConfiguration(QString("DialGadget"), qSettings);
return new DialGadgetConfiguration(QString("DialGadget"), settings);
}
IOptionsPage *DialGadgetFactory::createOptionsPage(IUAVGadgetConfiguration *config)

2
ground/gcs/src/plugins/dial/dialgadgetfactory.h
View File

@ -45,7 +45,7 @@ public:
~DialGadgetFactory();
Core::IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(QSettings *qSettings);
IUAVGadgetConfiguration *createConfiguration(QSettings &settings);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};

117
ground/gcs/src/plugins/gcscontrol/gcscontrolgadgetconfiguration.cpp
View File

@ -31,39 +31,43 @@
* Loads a saved configuration or defaults if non exist.
*
*/
GCSControlGadgetConfiguration::GCSControlGadgetConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent),
rollChannel(-1),
pitchChannel(-1),
yawChannel(-1),
throttleChannel(-1)
GCSControlGadgetConfiguration::GCSControlGadgetConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
int i;
controlsMode = settings.value("controlsMode").toInt();
rollChannel = settings.value("rollChannel", -1).toInt();
pitchChannel = settings.value("pitchChannel", -1).toInt();
yawChannel = settings.value("yawChannel", -1).toInt();
throttleChannel = settings.value("throttleChannel", -1).toInt();
for (i = 0; i < 8; i++) {
buttonSettings[i].ActionID = 0;
buttonSettings[i].FunctionID = 0;
buttonSettings[i].Amount = 0;
channelReverse[i] = 0;
udp_port = settings.value("controlPortUDP").toUInt();
udp_host = QHostAddress(settings.value("controlHostUDP").toString());
for (int i = 0; i < 8; i++) {
buttonSettings[i].ActionID = settings.value(QString().sprintf("button%dAction", i)).toInt();
buttonSettings[i].FunctionID = settings.value(QString().sprintf("button%dFunction", i)).toInt();
buttonSettings[i].Amount = settings.value(QString().sprintf("button%dAmount", i)).toDouble();
channelReverse[i] = settings.value(QString().sprintf("channel%dReverse", i)).toBool();
}
// if a saved configuration exists load it
if (qSettings != 0) {
controlsMode = qSettings->value("controlsMode").toInt();
rollChannel = qSettings->value("rollChannel").toInt();
pitchChannel = qSettings->value("pitchChannel").toInt();
yawChannel = qSettings->value("yawChannel").toInt();
throttleChannel = qSettings->value("throttleChannel").toInt();
}
udp_port = qSettings->value("controlPortUDP").toUInt();
udp_host = QHostAddress(qSettings->value("controlHostUDP").toString());
GCSControlGadgetConfiguration::GCSControlGadgetConfiguration(const GCSControlGadgetConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
controlsMode = obj.controlsMode;
rollChannel = obj.rollChannel;
pitchChannel = obj.pitchChannel;
yawChannel = obj.yawChannel;
throttleChannel = obj.throttleChannel;
int i;
for (i = 0; i < 8; i++) {
buttonSettings[i].ActionID = qSettings->value(QString().sprintf("button%dAction", i)).toInt();
buttonSettings[i].FunctionID = qSettings->value(QString().sprintf("button%dFunction", i)).toInt();
buttonSettings[i].Amount = qSettings->value(QString().sprintf("button%dAmount", i)).toDouble();
channelReverse[i] = qSettings->value(QString().sprintf("channel%dReverse", i)).toBool();
}
udp_host = obj.udp_host;
udp_port = obj.udp_port;
for (int i = 0; i < 8; i++) {
buttonSettings[i].ActionID = obj.buttonSettings[i].ActionID;
buttonSettings[i].FunctionID = obj.buttonSettings[i].FunctionID;
buttonSettings[i].Amount = obj.buttonSettings[i].Amount;
channelReverse[i] = obj.channelReverse[i];
}
}
@ -77,6 +81,7 @@ int GCSControlGadgetConfiguration::getUDPControlPort()
{
return udp_port;
}
QHostAddress GCSControlGadgetConfiguration::getUDPControlHost()
{
return udp_host;
@ -96,14 +101,13 @@ QList<int> GCSControlGadgetConfiguration::getChannelsMapping()
ql << rollChannel << pitchChannel << yawChannel << throttleChannel;
return ql;
}
QList<bool> GCSControlGadgetConfiguration::getChannelsReverse()
{
QList<bool> ql;
int i;
for (i = 0; i < 8; i++) {
for (int i = 0; i < 8; i++) {
ql << channelReverse[i];
}
return ql;
}
@ -111,51 +115,30 @@ QList<bool> GCSControlGadgetConfiguration::getChannelsReverse()
* Clones a configuration.
*
*/
IUAVGadgetConfiguration *GCSControlGadgetConfiguration::clone()
IUAVGadgetConfiguration *GCSControlGadgetConfiguration::clone() const
{
GCSControlGadgetConfiguration *m = new GCSControlGadgetConfiguration(this->classId());
m->controlsMode = controlsMode;
m->rollChannel = rollChannel;
m->pitchChannel = pitchChannel;
m->yawChannel = yawChannel;
m->throttleChannel = throttleChannel;
m->udp_host = udp_host;
m->udp_port = udp_port;
int i;
for (i = 0; i < 8; i++) {
m->buttonSettings[i].ActionID = buttonSettings[i].ActionID;
m->buttonSettings[i].FunctionID = buttonSettings[i].FunctionID;
m->buttonSettings[i].Amount = buttonSettings[i].Amount;
m->channelReverse[i] = channelReverse[i];
}
return m;
return new GCSControlGadgetConfiguration(*this);
}
/**
* Saves a configuration.
*
*/
void GCSControlGadgetConfiguration::saveConfig(QSettings *settings) const
void GCSControlGadgetConfiguration::saveConfig(QSettings &settings) const
{
settings->setValue("controlsMode", controlsMode);
settings->setValue("rollChannel", rollChannel);
settings->setValue("pitchChannel", pitchChannel);
settings->setValue("yawChannel", yawChannel);
settings->setValue("throttleChannel", throttleChannel);
settings.setValue("controlsMode", controlsMode);
settings.setValue("rollChannel", rollChannel);
settings.setValue("pitchChannel", pitchChannel);
settings.setValue("yawChannel", yawChannel);
settings.setValue("throttleChannel", throttleChannel);
settings->setValue("controlPortUDP", QString::number(udp_port));
settings->setValue("controlHostUDP", udp_host.toString());
settings.setValue("controlPortUDP", QString::number(udp_port));
settings.setValue("controlHostUDP", udp_host.toString());
int i;
for (i = 0; i < 8; i++) {
settings->setValue(QString().sprintf("button%dAction", i), buttonSettings[i].ActionID);
settings->setValue(QString().sprintf("button%dFunction", i), buttonSettings[i].FunctionID);
settings->setValue(QString().sprintf("button%dAmount", i), buttonSettings[i].Amount);
settings->setValue(QString().sprintf("channel%dReverse", i), channelReverse[i]);
for (int i = 0; i < 8; i++) {
settings.setValue(QString().sprintf("button%dAction", i), buttonSettings[i].ActionID);
settings.setValue(QString().sprintf("button%dFunction", i), buttonSettings[i].FunctionID);
settings.setValue(QString().sprintf("button%dAmount", i), buttonSettings[i].Amount);
settings.setValue(QString().sprintf("channel%dReverse", i), channelReverse[i]);
}
}

19
ground/gcs/src/plugins/gcscontrol/gcscontrolgadgetconfiguration.h
View File

@ -29,7 +29,8 @@
#define GCSCONTROLGADGETCONFIGURATION_H
#include <coreplugin/iuavgadgetconfiguration.h>
#include <QtNetwork/QHostAddress>
#include <QHostAddress>
typedef struct {
int ActionID;
@ -42,14 +43,16 @@ typedef struct {
QHostAddress address;
} portSettingsStruct;
using namespace Core;
class GCSControlGadgetConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT
public:
explicit GCSControlGadgetConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit GCSControlGadgetConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit GCSControlGadgetConfiguration(const GCSControlGadgetConfiguration &obj);
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
void setControlsMode(int mode)
{
@ -63,8 +66,8 @@ public:
{
return controlsMode;
}
QList<int> getChannelsMapping();
QList<bool> getChannelsReverse();
QList<int> getChannelsMapping();
QList<bool> getChannelsReverse();
buttonSettingsStruct getbuttonSettings(int i)
{
@ -87,10 +90,6 @@ public:
channelReverse[i] = Reverse;
}
void saveConfig(QSettings *settings) const;
IUAVGadgetConfiguration *clone();
private:
int controlsMode; // Mode1 to Mode4
// Joystick mappings for roll/pitch/yaw/throttle:

4
ground/gcs/src/plugins/gcscontrol/gcscontrolgadgetfactory.cpp
View File

@ -45,9 +45,9 @@ IUAVGadget *GCSControlGadgetFactory::createGadget(QWidget *parent)
return new GCSControlGadget(QString("GCSControlGadget"), gadgetWidget, parent, this->parent());
}
IUAVGadgetConfiguration *GCSControlGadgetFactory::createConfiguration(QSettings *qSettings)
IUAVGadgetConfiguration *GCSControlGadgetFactory::createConfiguration(QSettings &settings)
{
return new GCSControlGadgetConfiguration(QString("GCSControlGadget"), qSettings);
return new GCSControlGadgetConfiguration(QString("GCSControlGadget"), settings);
}
IOptionsPage *GCSControlGadgetFactory::createOptionsPage(IUAVGadgetConfiguration *config)

2
ground/gcs/src/plugins/gcscontrol/gcscontrolgadgetfactory.h
View File

@ -46,7 +46,7 @@ public:
~GCSControlGadgetFactory();
IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(QSettings *qSettings);
IUAVGadgetConfiguration *createConfiguration(QSettings &settings);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};

89
ground/gcs/src/plugins/gpsdisplay/gpsdisplaygadgetconfiguration.cpp
View File

@ -33,77 +33,52 @@
* Loads a saved configuration or defaults if non exist.
*
*/
GpsDisplayGadgetConfiguration::GpsDisplayGadgetConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent),
m_connectionMode("Serial"),
m_defaultPort("Unknown"),
m_defaultSpeed(QSerialPort::UnknownBaud),
m_defaultDataBits(QSerialPort::UnknownDataBits),
m_defaultFlow(QSerialPort::UnknownFlowControl),
m_defaultParity(QSerialPort::UnknownParity),
m_defaultStopBits(QSerialPort::UnknownStopBits),
m_defaultTimeOut(5000)
GpsDisplayGadgetConfiguration::GpsDisplayGadgetConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
// if a saved configuration exists load it
if (qSettings != 0) {
QSerialPort::BaudRate speed;
QSerialPort::DataBits databits;
QSerialPort::FlowControl flow;
QSerialPort::Parity parity;
QSerialPort::StopBits stopbits;
m_defaultPort = settings.value("defaultPort", "Unknown").toString();
m_defaultSpeed = (QSerialPort::BaudRate)settings.value("defaultSpeed", QSerialPort::UnknownBaud).toInt();
m_defaultDataBits = (QSerialPort::DataBits)settings.value("defaultDataBits", QSerialPort::UnknownDataBits).toInt();
m_defaultFlow = (QSerialPort::FlowControl)settings.value("defaultFlow", QSerialPort::UnknownFlowControl).toInt();
m_defaultParity = (QSerialPort::Parity)settings.value("defaultParity", QSerialPort::UnknownParity).toInt();
m_defaultStopBits = (QSerialPort::StopBits)settings.value("defaultStopBits", QSerialPort::UnknownStopBits).toInt();
m_connectionMode = settings.value("connectionMode", "Serial").toString();
m_defaultTimeOut = 5000;
}
int ispeed = qSettings->value("defaultSpeed").toInt();
int idatabits = qSettings->value("defaultDataBits").toInt();
int iflow = qSettings->value("defaultFlow").toInt();
int iparity = qSettings->value("defaultParity").toInt();
int istopbits = qSettings->value("defaultStopBits").toInt();
QString port = qSettings->value("defaultPort").toString();
QString conMode = qSettings->value("connectionMode").toString();
databits = (QSerialPort::DataBits)idatabits;
flow = (QSerialPort::FlowControl)iflow;
parity = (QSerialPort::Parity)iparity;
stopbits = (QSerialPort::StopBits)istopbits;
speed = (QSerialPort::BaudRate)ispeed;
m_defaultPort = port;
m_defaultSpeed = speed;
m_defaultDataBits = databits;
m_defaultFlow = flow;
m_defaultParity = parity;
m_defaultStopBits = stopbits;
m_connectionMode = conMode;
}
GpsDisplayGadgetConfiguration::GpsDisplayGadgetConfiguration(const GpsDisplayGadgetConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
m_defaultSpeed = obj.m_defaultSpeed;
m_defaultDataBits = obj.m_defaultDataBits;
m_defaultFlow = obj.m_defaultFlow;
m_defaultParity = obj.m_defaultParity;
m_defaultStopBits = obj.m_defaultStopBits;
m_defaultPort = obj.m_defaultPort;
m_connectionMode = obj.m_connectionMode;
m_defaultTimeOut = obj.m_defaultTimeOut;
}
/**
* Clones a configuration.
*
*/
IUAVGadgetConfiguration *GpsDisplayGadgetConfiguration::clone()
IUAVGadgetConfiguration *GpsDisplayGadgetConfiguration::clone() const
{
GpsDisplayGadgetConfiguration *m = new GpsDisplayGadgetConfiguration(this->classId());
m->m_defaultSpeed = m_defaultSpeed;
m->m_defaultDataBits = m_defaultDataBits;
m->m_defaultFlow = m_defaultFlow;
m->m_defaultParity = m_defaultParity;
m->m_defaultStopBits = m_defaultStopBits;
m->m_defaultPort = m_defaultPort;
m->m_connectionMode = m_connectionMode;
return m;
return new GpsDisplayGadgetConfiguration(*this);
}
/**
* Saves a configuration.
*
*/
void GpsDisplayGadgetConfiguration::saveConfig(QSettings *settings) const
void GpsDisplayGadgetConfiguration::saveConfig(QSettings &settings) const
{
settings->setValue("defaultSpeed", m_defaultSpeed);
settings->setValue("defaultDataBits", m_defaultDataBits);
settings->setValue("defaultFlow", m_defaultFlow);
settings->setValue("defaultParity", m_defaultParity);
settings->setValue("defaultStopBits", m_defaultStopBits);
settings->setValue("defaultPort", m_defaultPort);
settings->setValue("connectionMode", m_connectionMode);
settings.setValue("defaultSpeed", m_defaultSpeed);
settings.setValue("defaultDataBits", m_defaultDataBits);
settings.setValue("defaultFlow", m_defaultFlow);
settings.setValue("defaultParity", m_defaultParity);
settings.setValue("defaultStopBits", m_defaultStopBits);
settings.setValue("defaultPort", m_defaultPort);
settings.setValue("connectionMode", m_connectionMode);
}

10
ground/gcs/src/plugins/gpsdisplay/gpsdisplaygadgetconfiguration.h
View File

@ -49,7 +49,11 @@ struct PortSettings {
class GpsDisplayGadgetConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT
public:
explicit GpsDisplayGadgetConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit GpsDisplayGadgetConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit GpsDisplayGadgetConfiguration(const GpsDisplayGadgetConfiguration &obj);
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
void setConnectionMode(QString mode)
{
@ -59,7 +63,6 @@ public:
{
return m_connectionMode;
}
// set port configuration functions
void setSpeed(QSerialPort::BaudRate speed)
{
@ -120,9 +123,6 @@ public:
return m_defaultTimeOut;
}
void saveConfig(QSettings *settings) const;
IUAVGadgetConfiguration *clone();
private:
QString m_connectionMode;
QString m_defaultPort;

4
ground/gcs/src/plugins/gpsdisplay/gpsdisplaygadgetfactory.cpp
View File

@ -47,9 +47,9 @@ Core::IUAVGadget *GpsDisplayGadgetFactory::createGadget(QWidget *parent)
return new GpsDisplayGadget(QString("GpsDisplayGadget"), gadgetWidget, parent);
}
IUAVGadgetConfiguration *GpsDisplayGadgetFactory::createConfiguration(QSettings *qSettings)
IUAVGadgetConfiguration *GpsDisplayGadgetFactory::createConfiguration(QSettings &settings)
{
return new GpsDisplayGadgetConfiguration(QString("GpsDisplayGadget"), qSettings);
return new GpsDisplayGadgetConfiguration(QString("GpsDisplayGadget"), settings);
}
IOptionsPage *GpsDisplayGadgetFactory::createOptionsPage(IUAVGadgetConfiguration *config)

2
ground/gcs/src/plugins/gpsdisplay/gpsdisplaygadgetfactory.h
View File

@ -44,7 +44,7 @@ public:
~GpsDisplayGadgetFactory();
Core::IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(QSettings *qSettings);
IUAVGadgetConfiguration *createConfiguration(QSettings &settings);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};

25
ground/gcs/src/plugins/hitl/aerosimrc/src/settings.cpp
View File

@ -28,9 +28,8 @@
#include "settings.h"
Settings::Settings(QString settingsPath, QObject *parent) :
QObject(parent)
QObject(parent), settings(settingsPath + "/cc_plugin.ini", QSettings::IniFormat)
{
settings = new QSettings(settingsPath + "/cc_plugin.ini", QSettings::IniFormat);
// default settings
sendToHost = "127.0.0.1";
sendToPort = 40100;
@ -51,12 +50,12 @@ Settings::Settings(QString settingsPath, QObject *parent) :
void Settings::read()
{
// network
listenOnHost = settings->value("listen_on_host", listenOnHost).toString();
listenOnPort = settings->value("listen_on_port", listenOnPort).toInt();
sendToHost = settings->value("send_to_host", sendToHost).toString();
sendToPort = settings->value("send_to_port", sendToPort).toInt();
listenOnHost = settings.value("listen_on_host", listenOnHost).toString();
listenOnPort = settings.value("listen_on_port", listenOnPort).toInt();
sendToHost = settings.value("send_to_host", sendToHost).toString();
sendToPort = settings.value("send_to_port", sendToPort).toInt();
QString allChannels = settings->value("all_channels").toString();
QString allChannels = settings.value("all_channels").toString();
QString chan;
int i = 0;
foreach(chan, allChannels.split(" "))
@ -67,31 +66,31 @@ void Settings::read()
QString map = "";
for (quint8 i = 0; i < 10; ++i) {
num = QString::number(i + 1);
map = settings->value("Input/cc_channel_" + num).toString();
map = settings.value("Input/cc_channel_" + num).toString();
inputMap[i] = channels.value(map, inputMap.at(i));
}
QString sendTo = settings->value("Input/send_to", "RX").toString();
QString sendTo = settings.value("Input/send_to", "RX").toString();
sendToRX = (sendTo == "RX") ? true : false;
// outputs
for (quint8 i = 0; i < 8; ++i) {
num = QString::number(i + 1);
map = settings->value("Output/sim_channel_" + num).toString();
map = settings.value("Output/sim_channel_" + num).toString();
outputMap[i] = channels.value(map, outputMap.at(i));
}
QString takeFrom = settings->value("Output/take_from", "TX").toString();
QString takeFrom = settings.value("Output/take_from", "TX").toString();
takeFromTX = (takeFrom == "TX") ? true : false;
// video
quint8 resolutionNum = settings->value("Video/number_of_resolutions", 0).toInt();
quint8 resolutionNum = settings.value("Video/number_of_resolutions", 0).toInt();
if (resolutionNum > 0) {
videoModes.clear();
videoModes << resolutionNum;
for (quint8 i = 0; i < resolutionNum; ++i) {
num = QString::number(i + 1);
QString modes = settings->value("Video/resolution_" + num, "0, 0, 640, 480").toString();
QString modes = settings.value("Video/resolution_" + num, "0, 0, 640, 480").toString();
QString mode;
foreach(mode, modes.split(" "))
videoModes << mode.toInt();

3
ground/gcs/src/plugins/hitl/aerosimrc/src/settings.h
View File

@ -77,8 +77,9 @@ public:
}
private:
QSettings settings;
QHash<QString, quint8> channels;
QSettings *settings;
QString sendToHost;
quint16 sendToPort;
QString listenOnHost;

210
ground/gcs/src/plugins/hitl/hitlconfiguration.cpp
View File

@ -27,136 +27,138 @@
#include "hitlconfiguration.h"
HITLConfiguration::HITLConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
// Default settings values
#define DFLT_SIMULATOR_ID ""
#define DFLT_BIN_PATH ""
#define DFLT_DATA_PATH ""
#define DFLT_START_SIM false
#define DFLT_addNoise false
#define DFLT_ADD_NOISE false
#define DFLT_HOST_ADDRESS "127.0.0.1"
#define DFLT_REMOTE_ADDRESS "127.0.0.1"
#define DFLT_OUT_PORT 0
#define DFLT_IN_PORT 0
#define DFLT_LATITUDE ""
#define DFLT_LONGITUDE ""
#define DFLT_ATT_RAW_ENABLED false
#define DFLT_ATT_RAW_RATE 20
#define DFLT_ATT_STATE_ENABLED true
#define DFLT_ATT_ACT_HW false
#define DFLT_ATT_ACT_SIM true
#define DFLT_ATT_ACT_CALC false
#define DFLT_BARO_SENSOR_ENABLED false
#define DFLT_BARO_ALT_RATE 0
#define DFLT_GPS_POSITION_ENABLED false
#define DFLT_GPS_POS_RATE 100
#define DFLT_GROUND_TRUTH_ENABLED false
#define DFLT_GROUND_TRUTH_RATE 100
#define DFLT_INPUT_COMMAND false
#define DFLT_GCS_RECEIVER_ENABLED false
#define DFLT_MANUAL_CONTROL_ENABLED false
#define DFLT_MIN_INPUT_PERIOD 100
#define DFLT_AIRSPEED_STATE_ENABLED false
#define DFLT_AIRSPEED_STATE_RATE 100
HITLConfiguration::HITLConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
// Default settings values
settings.simulatorId = "";
settings.binPath = "";
settings.dataPath = "";
settings.manualControlEnabled = true;
settings.startSim = false;
settings.addNoise = false;
settings.hostAddress = "127.0.0.1";
settings.remoteAddress = "127.0.0.1";
settings.outPort = 0;
settings.inPort = 0;
settings.latitude = "";
settings.longitude = "";
simSettings.simulatorId = settings.value("simulatorId", DFLT_SIMULATOR_ID).toString();
simSettings.binPath = settings.value("binPath", DFLT_BIN_PATH).toString();
simSettings.dataPath = settings.value("dataPath", DFLT_DATA_PATH).toString();
settings.attRawEnabled = false;
settings.attRawRate = 20;
simSettings.hostAddress = settings.value("hostAddress", DFLT_HOST_ADDRESS).toString();
simSettings.remoteAddress = settings.value("remoteAddress", DFLT_REMOTE_ADDRESS).toString();
simSettings.outPort = settings.value("outPort", DFLT_OUT_PORT).toInt();
simSettings.inPort = settings.value("inPort", DFLT_IN_PORT).toInt();
settings.attStateEnabled = true;
settings.attActHW = false;
settings.attActSim = true;
settings.attActCalc = false;
simSettings.latitude = settings.value("latitude", DFLT_LATITUDE).toString();
simSettings.longitude = settings.value("longitude", DFLT_LONGITUDE).toString();
simSettings.startSim = settings.value("startSim", DFLT_START_SIM).toBool();
simSettings.addNoise = settings.value("noiseCheckBox", DFLT_ADD_NOISE).toBool();
settings.gpsPositionEnabled = false;
settings.gpsPosRate = 100;
simSettings.gcsReceiverEnabled = settings.value("gcsReceiverEnabled", DFLT_GCS_RECEIVER_ENABLED).toBool();
simSettings.manualControlEnabled = settings.value("manualControlEnabled", DFLT_MANUAL_CONTROL_ENABLED).toBool();
settings.groundTruthEnabled = false;
settings.groundTruthRate = 100;
simSettings.attRawEnabled = settings.value("attRawEnabled", DFLT_ATT_RAW_ENABLED).toBool();
simSettings.attRawRate = settings.value("attRawRate", DFLT_ATT_RAW_RATE).toInt();
settings.inputCommand = false;
settings.gcsReceiverEnabled = false;
settings.manualControlEnabled = false;
settings.minOutputPeriod = 100;
simSettings.attStateEnabled = settings.value("attStateEnabled", DFLT_ATT_STATE_ENABLED).toBool();
simSettings.attActHW = settings.value("attActHW", DFLT_ATT_ACT_HW).toBool();
simSettings.attActSim = settings.value("attActSim", DFLT_ATT_ACT_SIM).toBool();
simSettings.attActCalc = settings.value("attActCalc", DFLT_ATT_ACT_CALC).toBool();
settings.airspeedStateEnabled = false;
settings.airspeedStateRate = 100;
simSettings.baroSensorEnabled = settings.value("baroSensorEnabled", DFLT_BARO_SENSOR_ENABLED).toBool();
simSettings.baroAltRate = settings.value("baroAltRate", DFLT_BARO_ALT_RATE).toInt();
simSettings.gpsPositionEnabled = settings.value("gpsPositionEnabled", DFLT_GPS_POSITION_ENABLED).toBool();
simSettings.gpsPosRate = settings.value("gpsPosRate", DFLT_GPS_POS_RATE).toInt();
// if a saved configuration exists load it, and overwrite defaults
if (qSettings != 0) {
settings.simulatorId = qSettings->value("simulatorId").toString();
settings.binPath = qSettings->value("binPath").toString();
settings.dataPath = qSettings->value("dataPath").toString();
simSettings.groundTruthEnabled = settings.value("groundTruthEnabled", DFLT_GROUND_TRUTH_ENABLED).toBool();
simSettings.groundTruthRate = settings.value("groundTruthRate", DFLT_GROUND_TRUTH_RATE).toInt();
settings.hostAddress = qSettings->value("hostAddress").toString();
settings.remoteAddress = qSettings->value("remoteAddress").toString();
settings.outPort = qSettings->value("outPort").toInt();
settings.inPort = qSettings->value("inPort").toInt();
simSettings.inputCommand = settings.value("inputCommand", DFLT_INPUT_COMMAND).toBool();
simSettings.minOutputPeriod = settings.value("minOutputPeriod", DFLT_MIN_INPUT_PERIOD).toInt();
settings.latitude = qSettings->value("latitude").toString();
settings.longitude = qSettings->value("longitude").toString();
settings.startSim = qSettings->value("startSim").toBool();
settings.addNoise = qSettings->value("noiseCheckBox").toBool();
settings.gcsReceiverEnabled = qSettings->value("gcsReceiverEnabled").toBool();
settings.manualControlEnabled = qSettings->value("manualControlEnabled").toBool();
settings.attRawEnabled = qSettings->value("attRawEnabled").toBool();
settings.attRawRate = qSettings->value("attRawRate").toInt();
settings.attStateEnabled = qSettings->value("attStateEnabled").toBool();
settings.attActHW = qSettings->value("attActHW").toBool();
settings.attActSim = qSettings->value("attActSim").toBool();
settings.attActCalc = qSettings->value("attActCalc").toBool();
settings.baroSensorEnabled = qSettings->value("baroSensorEnabled").toBool();
settings.baroAltRate = qSettings->value("baroAltRate").toInt();
settings.gpsPositionEnabled = qSettings->value("gpsPositionEnabled").toBool();
settings.gpsPosRate = qSettings->value("gpsPosRate").toInt();
settings.groundTruthEnabled = qSettings->value("groundTruthEnabled").toBool();
settings.groundTruthRate = qSettings->value("groundTruthRate").toInt();
settings.inputCommand = qSettings->value("inputCommand").toBool();
settings.minOutputPeriod = qSettings->value("minOutputPeriod").toInt();
settings.airspeedStateEnabled = qSettings->value("airspeedStateEnabled").toBool();
settings.airspeedStateRate = qSettings->value("airspeedStateRate").toInt();
}
simSettings.airspeedStateEnabled = settings.value("airspeedStateEnabled", DFLT_AIRSPEED_STATE_ENABLED).toBool();
simSettings.airspeedStateRate = settings.value("airspeedStateRate", DFLT_AIRSPEED_STATE_RATE).toInt();
}
IUAVGadgetConfiguration *HITLConfiguration::clone()
HITLConfiguration::HITLConfiguration(const HITLConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
HITLConfiguration *m = new HITLConfiguration(this->classId());
simSettings = obj.simSettings;
}
m->settings = settings;
return m;
IUAVGadgetConfiguration *HITLConfiguration::clone() const
{
return new HITLConfiguration(*this);
}
/**
* Saves a configuration.
*
*/
void HITLConfiguration::saveConfig(QSettings *qSettings) const
void HITLConfiguration::saveConfig(QSettings &settings) const
{
qSettings->setValue("simulatorId", settings.simulatorId);
qSettings->setValue("binPath", settings.binPath);
qSettings->setValue("dataPath", settings.dataPath);
settings.setValue("simulatorId", simSettings.simulatorId);
settings.setValue("binPath", simSettings.binPath);
settings.setValue("dataPath", simSettings.dataPath);
qSettings->setValue("hostAddress", settings.hostAddress);
qSettings->setValue("remoteAddress", settings.remoteAddress);
qSettings->setValue("outPort", settings.outPort);
qSettings->setValue("inPort", settings.inPort);
settings.setValue("hostAddress", simSettings.hostAddress);
settings.setValue("remoteAddress", simSettings.remoteAddress);
settings.setValue("outPort", simSettings.outPort);
settings.setValue("inPort", simSettings.inPort);
qSettings->setValue("latitude", settings.latitude);
qSettings->setValue("longitude", settings.longitude);
qSettings->setValue("addNoise", settings.addNoise);
qSettings->setValue("startSim", settings.startSim);
settings.setValue("latitude", simSettings.latitude);
settings.setValue("longitude", simSettings.longitude);
settings.setValue("addNoise", simSettings.addNoise);
settings.setValue("startSim", simSettings.startSim);
qSettings->setValue("gcsReceiverEnabled", settings.gcsReceiverEnabled);
qSettings->setValue("manualControlEnabled", settings.manualControlEnabled);
settings.setValue("gcsReceiverEnabled", simSettings.gcsReceiverEnabled);
settings.setValue("manualControlEnabled", simSettings.manualControlEnabled);
qSettings->setValue("attRawEnabled", settings.attRawEnabled);
qSettings->setValue("attRawRate", settings.attRawRate);
qSettings->setValue("attStateEnabled", settings.attStateEnabled);
qSettings->setValue("attActHW", settings.attActHW);
qSettings->setValue("attActSim", settings.attActSim);
qSettings->setValue("attActCalc", settings.attActCalc);
qSettings->setValue("baroSensorEnabled", settings.baroSensorEnabled);
qSettings->setValue("baroAltRate", settings.baroAltRate);
qSettings->setValue("gpsPositionEnabled", settings.gpsPositionEnabled);
qSettings->setValue("gpsPosRate", settings.gpsPosRate);
qSettings->setValue("groundTruthEnabled", settings.groundTruthEnabled);
qSettings->setValue("groundTruthRate", settings.groundTruthRate);
qSettings->setValue("inputCommand", settings.inputCommand);
qSettings->setValue("minOutputPeriod", settings.minOutputPeriod);
settings.setValue("attRawEnabled", simSettings.attRawEnabled);
settings.setValue("attRawRate", simSettings.attRawRate);
settings.setValue("attStateEnabled", simSettings.attStateEnabled);
settings.setValue("attActHW", simSettings.attActHW);
settings.setValue("attActSim", simSettings.attActSim);
settings.setValue("attActCalc", simSettings.attActCalc);
settings.setValue("baroSensorEnabled", simSettings.baroSensorEnabled);
settings.setValue("baroAltRate", simSettings.baroAltRate);
settings.setValue("gpsPositionEnabled", simSettings.gpsPositionEnabled);
settings.setValue("gpsPosRate", simSettings.gpsPosRate);
settings.setValue("groundTruthEnabled", simSettings.groundTruthEnabled);
settings.setValue("groundTruthRate", simSettings.groundTruthRate);
settings.setValue("inputCommand", simSettings.inputCommand);
settings.setValue("minOutputPeriod", simSettings.minOutputPeriod);
qSettings->setValue("airspeedStateEnabled", settings.airspeedStateEnabled);
qSettings->setValue("airspeedStateRate", settings.airspeedStateRate);
settings.setValue("airspeedStateEnabled", simSettings.airspeedStateEnabled);
settings.setValue("airspeedStateRate", simSettings.airspeedStateRate);
}

14
ground/gcs/src/plugins/hitl/hitlconfiguration.h
View File

@ -29,7 +29,6 @@
#define HITLCONFIGURATION_H
#include <coreplugin/iuavgadgetconfiguration.h>
#include <QColor>
#include <QString>
#include <simulator.h>
@ -40,25 +39,26 @@ class HITLConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT Q_PROPERTY(SimulatorSettings settings READ Settings WRITE setSimulatorSettings)
public:
explicit HITLConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit HITLConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit HITLConfiguration(const HITLConfiguration &obj);
void saveConfig(QSettings *settings) const;
IUAVGadgetConfiguration *clone();
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
SimulatorSettings Settings() const
{
return settings;
return simSettings;
}
public slots:
void setSimulatorSettings(const SimulatorSettings & params)
{
settings = params;
simSettings = params;
}
private:
SimulatorSettings settings;
SimulatorSettings simSettings;
};
#endif // HITLCONFIGURATION_H

4
ground/gcs/src/plugins/hitl/hitlfactory.cpp
View File

@ -45,9 +45,9 @@ Core::IUAVGadget *HITLFactory::createGadget(QWidget *parent)
return new HITLGadget(QString("HITL"), gadgetWidget, parent);
}
IUAVGadgetConfiguration *HITLFactory::createConfiguration(QSettings *qSettings)
IUAVGadgetConfiguration *HITLFactory::createConfiguration(QSettings &settings)
{
return new HITLConfiguration(QString("HITL"), qSettings);
return new HITLConfiguration(QString("HITL"), settings);
}
IOptionsPage *HITLFactory::createOptionsPage(IUAVGadgetConfiguration *config)

2
ground/gcs/src/plugins/hitl/hitlfactory.h
View File

@ -44,7 +44,7 @@ public:
~HITLFactory();
IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(QSettings *qSettings);
IUAVGadgetConfiguration *createConfiguration(QSettings &settings);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};

21
ground/gcs/src/plugins/importexport/importexportgadgetwidget.cpp
View File

@ -28,13 +28,15 @@
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "importexportgadgetwidget.h"
#include "ui_importexportgadgetwidget.h"
#include "utils/xmlconfig.h"
#include "coreplugin/uavgadgetinstancemanager.h"
#include "coreplugin/icore.h"
#include <extensionsystem/pluginmanager.h>
#include <extensionsystem/pluginspec.h>
#include <QtDebug>
#include <QDebug>
#include <QSettings>
#include <QMessageBox>
#include <QFileInfo>
@ -125,18 +127,17 @@ void ImportExportGadgetWidget::exportConfiguration(const QString & fileName)
bool doAllGadgets = ui->checkBoxAllGadgets->isChecked();
bool doPlugins = ui->checkBoxPlugins->isChecked();
QSettings::Format format = XmlConfig::XmlSettingsFormat;
QSettings qs(fileName, format);
QSettings settings(fileName, XmlConfig::XmlFormat);
if (doGeneral) {
Core::ICore::instance()->saveMainSettings(&qs);
Core::ICore::instance()->saveMainSettings(settings);
}
if (doAllGadgets) {
Core::ICore::instance()->uavGadgetInstanceManager()->saveSettings(&qs);
Core::ICore::instance()->uavGadgetInstanceManager()->saveSettings(settings);
}
if (doPlugins) {
foreach(Core::IConfigurablePlugin * plugin, getConfigurables()) {
Core::ICore::instance()->saveSettings(plugin, &qs);
Core::ICore::instance()->saveSettings(plugin, settings);
}
}
@ -184,17 +185,17 @@ void ImportExportGadgetWidget::importConfiguration(const QString & fileName)
bool doAllGadgets = ui->checkBoxAllGadgets->isChecked();
bool doPlugins = ui->checkBoxPlugins->isChecked();
QSettings qs(fileName, XmlConfig::XmlSettingsFormat);
QSettings settings(fileName, XmlConfig::XmlFormat);
if (doAllGadgets) {
Core::ICore::instance()->uavGadgetInstanceManager()->readSettings(&qs);
Core::ICore::instance()->uavGadgetInstanceManager()->readSettings(settings);
}
if (doGeneral) {
Core::ICore::instance()->readMainSettings(&qs);
Core::ICore::instance()->readMainSettings(settings);
}
if (doPlugins) {
foreach(Core::IConfigurablePlugin * plugin, getConfigurables()) {
Core::ICore::instance()->readSettings(plugin, &qs);
Core::ICore::instance()->readSettings(plugin, settings);
}
}

2
ground/gcs/src/plugins/ipconnection/ipconnection.pro
View File

@ -3,7 +3,7 @@ TARGET = IPconnection
QT += network widgets
DEFINES += IPconnection_LIBRARY
DEFINES += IPCONNECTION_LIBRARY
include(../../plugin.pri)
include(ipconnection_dependencies.pri)

19
ground/gcs/src/plugins/ipconnection/ipconnection_global.h
View File

@ -1,13 +1,14 @@
/**
******************************************************************************
*
* @file IPconnection_global.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file ipconnection_global.h
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup IPConnPlugin IP Telemetry Plugin
* @{
* @brief IP Connection Plugin impliment telemetry over TCP/IP and UDP/IP
* @brief IP Connection Plugin implements telemetry over TCP/IP and UDP/IP
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
@ -25,15 +26,15 @@
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef IPconnection_GLOBAL_H
#define IPconnection_GLOBAL_H
#ifndef IPCONNECTION_GLOBAL_H
#define IPCONNECTION_GLOBAL_H
#include <QtCore/qglobal.h>
#if defined(IPconnection_LIBRARY)
# define IPconnection_EXPORT Q_DECL_EXPORT
#if defined(IPCONNECTION_LIBRARY)
# define IPCONNECTION_EXPORT Q_DECL_EXPORT
#else
# define IPconnection_EXPORT Q_DECL_IMPORT
# define IPCONNECTION_EXPORT Q_DECL_IMPORT
#endif
#endif // IPconnection_GLOBAL_H
#endif // IPCONNECTION_GLOBAL_H

5
ground/gcs/src/plugins/ipconnection/ipconnection_internal.h
View File

@ -9,12 +9,9 @@ class IPConnection : public QObject {
Q_OBJECT
public:
IPConnection(IPconnectionConnection *connection);
// virtual ~IPConnection();
IPConnection(IPConnectionConnection *connection);
public slots:
void onOpenDevice(QString HostName, int Port, bool UseTCP);
void onCloseDevice(QAbstractSocket *ipSocket);
};

75
ground/gcs/src/plugins/ipconnection/ipconnectionconfiguration.cpp
View File

@ -1,13 +1,14 @@
/**
******************************************************************************
*
* @file IPconnectionconfiguration.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file ipconnectionconfiguration.cpp
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup IPConnPlugin IP Telemetry Plugin
* @{
* @brief IP Connection Plugin impliment telemetry over TCP/IP and UDP/IP
* @brief IP Connection Plugin implements telemetry over TCP/IP and UDP/IP
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
@ -26,66 +27,40 @@
*/
#include "ipconnectionconfiguration.h"
#include <coreplugin/icore.h>
IPconnectionConfiguration::IPconnectionConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent),
m_HostName("127.0.0.1"),
m_Port(1000),
m_UseTCP(1)
IPConnectionConfiguration::IPConnectionConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
Q_UNUSED(qSettings);
settings = Core::ICore::instance()->settings();
m_hostName = settings.value("HostName", "").toString();
m_port = settings.value("Port", 9000).toInt();
m_useTCP = settings.value("UseTCP", true).toInt();
}
IPconnectionConfiguration::~IPconnectionConfiguration()
IPConnectionConfiguration::IPConnectionConfiguration(const IPConnectionConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
m_hostName = obj.m_hostName;
m_port = obj.m_port;
m_useTCP = obj.m_useTCP;
}
IPConnectionConfiguration::~IPConnectionConfiguration()
{}
IUAVGadgetConfiguration *IPconnectionConfiguration::clone()
IUAVGadgetConfiguration *IPConnectionConfiguration::clone() const
{
IPconnectionConfiguration *m = new IPconnectionConfiguration(this->classId());
m->m_Port = m_Port;
m->m_HostName = m_HostName;
m->m_UseTCP = m_UseTCP;
return m;
return new IPConnectionConfiguration(*this);
}
/**
* Saves a configuration.
*
*/
void IPconnectionConfiguration::saveConfig(QSettings *qSettings) const
void IPConnectionConfiguration::saveConfig(QSettings &settings) const
{
qSettings->setValue("port", m_Port);
qSettings->setValue("hostName", m_HostName);
qSettings->setValue("useTCP", m_UseTCP);
}
void IPconnectionConfiguration::savesettings() const
{
settings->beginGroup(QLatin1String("IPconnection"));
settings->beginWriteArray("Current");
settings->setArrayIndex(0);
settings->setValue(QLatin1String("HostName"), m_HostName);
settings->setValue(QLatin1String("Port"), m_Port);
settings->setValue(QLatin1String("UseTCP"), m_UseTCP);
settings->endArray();
settings->endGroup();
}
void IPconnectionConfiguration::restoresettings()
{
settings->beginGroup(QLatin1String("IPconnection"));
settings->beginReadArray("Current");
settings->setArrayIndex(0);
m_HostName = (settings->value(QLatin1String("HostName"), tr("")).toString());
m_Port = (settings->value(QLatin1String("Port"), tr("")).toInt());
m_UseTCP = (settings->value(QLatin1String("UseTCP"), tr("")).toInt());
settings->endArray();
settings->endGroup();
settings.setValue("HostName", m_hostName);
settings.setValue("Port", m_port);
settings.setValue("UseTCP", m_useTCP);
}

81
ground/gcs/src/plugins/ipconnection/ipconnectionconfiguration.h
View File

@ -1,13 +1,14 @@
/**
******************************************************************************
*
* @file IPconnectionconfiguration.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file ipconnectionconfiguration.h
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup IPConnPlugin IP Telemetry Plugin
* @{
* @brief IP Connection Plugin impliment telemetry over TCP/IP and UDP/IP
* @brief IP Connection Plugin implements telemetry over TCP/IP and UDP/IP
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
@ -25,64 +26,60 @@
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef IPconnectionCONFIGURATION_H
#define IPconnectionCONFIGURATION_H
#ifndef IPCONFIGURATIONCONFIGURATION_H
#define IPCONFIGURATIONCONFIGURATION_H
#include <coreplugin/iuavgadgetconfiguration.h>
#include <QtCore/QString>
#include <QtCore/QSettings>
#include <QString>
using namespace Core;
class IPconnectionConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT Q_PROPERTY(QString HostName READ HostName WRITE setHostName)
Q_PROPERTY(int Port READ Port WRITE setPort)
Q_PROPERTY(int UseTCP READ UseTCP WRITE setUseTCP)
class IPConnectionConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT Q_PROPERTY(QString HostName READ hostName WRITE setHostName)
Q_PROPERTY(int Port READ port WRITE setPort)
Q_PROPERTY(int UseTCP READ useTCP WRITE setUseTCP)
public:
explicit IPconnectionConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit IPConnectionConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit IPConnectionConfiguration(const IPConnectionConfiguration &obj);
virtual ~IPconnectionConfiguration();
void saveConfig(QSettings *settings) const;
// void savesettings(QSettings* settings) const;
// void restoresettings(QSettings* settings);
void savesettings() const;
void restoresettings();
IUAVGadgetConfiguration *clone();
virtual ~IPConnectionConfiguration();
QString HostName() const
{
return m_HostName;
}
int Port() const
{
return m_Port;
}
int UseTCP() const
{
return m_UseTCP;
}
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
QString hostName() const
{
return m_hostName;
}
int port() const
{
return m_port;
}
int useTCP() const
{
return m_useTCP;
}
public slots:
void setHostName(QString HostName)
void setHostName(QString hostName)
{
m_HostName = HostName;
m_hostName = hostName;
}
void setPort(int Port)
void setPort(int port)
{
m_Port = Port;
m_port = port;
}
void setUseTCP(int UseTCP)
void setUseTCP(int useTCP)
{
m_UseTCP = UseTCP;
m_useTCP = useTCP;
}
private:
QString m_HostName;
int m_Port;
int m_UseTCP;
QSettings *settings;
QString m_hostName;
int m_port;
int m_useTCP;
};
#endif // IPconnectionCONFIGURATION_H
#endif // IPCONFIGURATIONCONFIGURATION_H

42
ground/gcs/src/plugins/ipconnection/ipconnectionoptionspage.cpp
View File

@ -1,13 +1,14 @@
/**
******************************************************************************
*
* @file IPconnectionoptionspage.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file ipconnectionoptionspage.cpp
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup IPConnPlugin IP Telemetry Plugin
* @{
* @brief IP Connection Plugin impliment telemetry over TCP/IP and UDP/IP
* @brief IP Connection Plugin implements telemetry over TCP/IP and UDP/IP
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
@ -26,49 +27,44 @@
*/
#include "ipconnectionoptionspage.h"
#include "ipconnectionconfiguration.h"
#include <QLabel>
#include <QComboBox>
#include <QSpinBox>
#include <QDoubleSpinBox>
#include <QRadioButton>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include "ui_ipconnectionoptionspage.h"
#include "ipconnectionconfiguration.h"
IPconnectionOptionsPage::IPconnectionOptionsPage(IPconnectionConfiguration *config, QObject *parent) :
IOptionsPage(parent),
m_config(config)
IPConnectionOptionsPage::IPConnectionOptionsPage(IPConnectionConfiguration *config, QObject *parent) :
IOptionsPage(parent), m_page(0), m_config(config)
{}
IPconnectionOptionsPage::~IPconnectionOptionsPage()
IPConnectionOptionsPage::~IPConnectionOptionsPage()
{}
QWidget *IPconnectionOptionsPage::createPage(QWidget *parent)
QWidget *IPConnectionOptionsPage::createPage(QWidget *parent)
{
m_page = new Ui::IPconnectionOptionsPage();
QWidget *w = new QWidget(parent);
m_page->setupUi(w);
m_page->Port->setValue(m_config->Port());
m_page->HostName->setText(m_config->HostName());
m_page->UseTCP->setChecked(m_config->UseTCP() ? true : false);
m_page->UseUDP->setChecked(m_config->UseTCP() ? false : true);
m_page->Port->setValue(m_config->port());
m_page->HostName->setText(m_config->hostName());
m_page->UseTCP->setChecked(m_config->useTCP() ? true : false);
m_page->UseUDP->setChecked(m_config->useTCP() ? false : true);
return w;
}
void IPconnectionOptionsPage::apply()
void IPConnectionOptionsPage::apply()
{
m_config->setPort(m_page->Port->value());
m_config->setHostName(m_page->HostName->text());
m_config->setUseTCP(m_page->UseTCP->isChecked() ? 1 : 0);
m_config->savesettings();
// FIXME this signal is too low level (and duplicated all over the place)
// FIXME this signal will trigger (amongst other things) the saving of the configuration !
emit availableDevChanged();
}
void IPconnectionOptionsPage::finish()
void IPConnectionOptionsPage::finish()
{
delete m_page;
}

28
ground/gcs/src/plugins/ipconnection/ipconnectionoptionspage.h
View File

@ -1,13 +1,14 @@
/**
******************************************************************************
*
* @file IPconnectionoptionspage.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file ipconnectionoptionspage.h
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup IPConnPlugin IP Telemetry Plugin
* @{
* @brief IP Connection Plugin impliment telemetry over TCP/IP and UDP/IP
* @brief IP Connection Plugin implements telemetry over TCP/IP and UDP/IP
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
@ -25,16 +26,12 @@
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef IPconnectionOPTIONSPAGE_H
#define IPconnectionOPTIONSPAGE_H
#ifndef IPCONNECTIONOPTIONSPAGE_H
#define IPCONNECTIONOPTIONSPAGE_H
#include "coreplugin/dialogs/ioptionspage.h"
class IPconnectionConfiguration;
namespace Core {
class IUAVGadgetConfiguration;
}
class IPConnectionConfiguration;
namespace Ui {
class IPconnectionOptionsPage;
@ -42,11 +39,11 @@ class IPconnectionOptionsPage;
using namespace Core;
class IPconnectionOptionsPage : public IOptionsPage {
class IPConnectionOptionsPage : public IOptionsPage {
Q_OBJECT
public:
explicit IPconnectionOptionsPage(IPconnectionConfiguration *config, QObject *parent = 0);
virtual ~IPconnectionOptionsPage();
explicit IPConnectionOptionsPage(IPConnectionConfiguration *config, QObject *parent = 0);
virtual ~IPConnectionOptionsPage();
QString id() const
{
@ -72,10 +69,9 @@ public:
signals:
void availableDevChanged();
public slots:
private:
IPconnectionConfiguration *m_config;
Ui::IPconnectionOptionsPage *m_page;
IPConnectionConfiguration *m_config;
};
#endif // IPconnectionOPTIONSPAGE_H
#endif // IPCONNECTIONOPTIONSPAGE_H

161
ground/gcs/src/plugins/ipconnection/ipconnectionplugin.cpp
View File

@ -1,13 +1,14 @@
/**
******************************************************************************
*
* @file IPconnectionplugin.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file ipconnectionplugin.cpp
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup IPConnPlugin IP Telemetry Plugin
* @{
* @brief IP Connection Plugin impliment telemetry over TCP/IP and UDP/IP
* @brief IP Connection Plugin implements telemetry over TCP/IP and UDP/IP
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
@ -29,12 +30,12 @@
#include "ipconnectionplugin.h"
#include "ipconnection_internal.h"
#include <extensionsystem/pluginmanager.h>
#include <coreplugin/icore.h>
#include "ipconnection_internal.h"
#include <coreplugin/threadmanager.h>
#include <QtCore/QtPlugin>
#include <QMainWindow>
#include <QMessageBox>
#include <QtNetwork/QAbstractSocket>
@ -42,11 +43,9 @@
#include <QtNetwork/QUdpSocket>
#include <QWaitCondition>
#include <QMutex>
#include <coreplugin/threadmanager.h>
#include <QDebug>
// Communication between IPconnectionConnection::OpenDevice() and IPConnection::onOpenDevice()
// Communication between IPConnectionConnection::OpenDevice() and IPConnection::onOpenDevice()
QString errorMsg;
QWaitCondition openDeviceWait;
QWaitCondition closeDeviceWait;
@ -54,7 +53,7 @@ QWaitCondition closeDeviceWait;
QMutex ipConMutex;
QAbstractSocket *ret;
IPConnection::IPConnection(IPconnectionConnection *connection) : QObject()
IPConnection::IPConnection(IPConnectionConnection *connection) : QObject()
{
moveToThread(Core::ICore::instance()->threadManager()->getRealTimeThread());
@ -117,14 +116,11 @@ void IPConnection::onCloseDevice(QAbstractSocket *ipSocket)
IPConnection *connection = 0;
IPconnectionConnection::IPconnectionConnection()
IPConnectionConnection::IPConnectionConnection(IPConnectionConfiguration *config) : m_config(config)
{
ipSocket = NULL;
// create all our objects
m_config = new IPconnectionConfiguration("IP Network Telemetry", NULL, this);
m_config->restoresettings();
m_ipSocket = NULL;
m_optionspage = new IPconnectionOptionsPage(m_config, this);
m_optionsPage = new IPConnectionOptionsPage(m_config, this);
if (!connection) {
connection = new IPConnection(this);
@ -132,17 +128,17 @@ IPconnectionConnection::IPconnectionConnection()
// just signal whenever we have a device event...
QMainWindow *mw = Core::ICore::instance()->mainWindow();
QObject::connect(mw, SIGNAL(deviceChange()),
this, SLOT(onEnumerationChanged()));
QObject::connect(m_optionspage, SIGNAL(availableDevChanged()),
this, SLOT(onEnumerationChanged()));
QObject::connect(mw, SIGNAL(deviceChange()), this, SLOT(onEnumerationChanged()));
QObject::connect(m_optionsPage, SIGNAL(availableDevChanged()), this, SLOT(onEnumerationChanged()));
}
IPconnectionConnection::~IPconnectionConnection()
{ // clean up out resources...
if (ipSocket) {
ipSocket->close();
delete (ipSocket);
IPConnectionConnection::~IPConnectionConnection()
{
// clean up out resources...
if (m_ipSocket) {
m_ipSocket->close();
delete m_ipSocket;
m_ipSocket = NULL;
}
if (connection) {
delete connection;
@ -150,81 +146,80 @@ IPconnectionConnection::~IPconnectionConnection()
}
}
void IPconnectionConnection::onEnumerationChanged()
{ // no change from serial plugin
void IPConnectionConnection::onEnumerationChanged()
{
emit availableDevChanged(this);
}
QList <Core::IConnection::device> IPconnectionConnection::availableDevices()
QList <Core::IConnection::device> IPConnectionConnection::availableDevices()
{
QList <Core::IConnection::device> list;
device d;
if (m_config->HostName().length() > 1) {
d.displayName = (const QString)m_config->HostName();
if (m_config->hostName().length() > 1) {
d.displayName = (const QString)m_config->hostName();
} else {
d.displayName = "Unconfigured";
d.displayName = tr("Unconfigured");
}
d.name = (const QString)m_config->HostName();
d.name = (const QString)m_config->hostName();
// we only have one "device" as defined by the configuration m_config
list.append(d);
return list;
}
QIODevice *IPconnectionConnection::openDevice(const QString &)
QIODevice *IPConnectionConnection::openDevice(const QString &)
{
QString HostName;
int Port;
bool UseTCP;
QString hostName;
int port;
bool useTCP;
QMessageBox msgBox;
// get the configuration info
HostName = m_config->HostName();
Port = m_config->Port();
UseTCP = m_config->UseTCP();
hostName = m_config->hostName();
port = m_config->port();
useTCP = m_config->useTCP();
if (ipSocket) {
if (m_ipSocket) {
// Andrew: close any existing socket... this should never occur
ipConMutex.lock();
emit CloseSocket(ipSocket);
emit CloseSocket(m_ipSocket);
closeDeviceWait.wait(&ipConMutex);
ipConMutex.unlock();
ipSocket = NULL;
m_ipSocket = NULL;
}
ipConMutex.lock();
emit CreateSocket(HostName, Port, UseTCP);
emit CreateSocket(hostName, port, useTCP);
openDeviceWait.wait(&ipConMutex);
ipConMutex.unlock();
ipSocket = ret;
if (ipSocket == NULL) {
m_ipSocket = ret;
if (m_ipSocket == NULL) {
msgBox.setText((const QString)errorMsg);
msgBox.exec();
}
return ipSocket;
return m_ipSocket;
}
void IPconnectionConnection::closeDevice(const QString &)
void IPConnectionConnection::closeDevice(const QString &)
{
if (ipSocket) {
if (m_ipSocket) {
ipConMutex.lock();
emit CloseSocket(ipSocket);
emit CloseSocket(m_ipSocket);
closeDeviceWait.wait(&ipConMutex);
ipConMutex.unlock();
ipSocket = NULL;
m_ipSocket = NULL;
}
}
QString IPconnectionConnection::connectionName()
{ // updated from serial plugin
QString IPConnectionConnection::connectionName()
{
return QString("Network telemetry port");
}
QString IPconnectionConnection::shortName()
{ // updated from serial plugin
if (m_config->UseTCP()) {
QString IPConnectionConnection::shortName()
{
if (m_config->useTCP()) {
return QString("TCP");
} else {
return QString("UDP");
@ -232,29 +227,55 @@ QString IPconnectionConnection::shortName()
}
IPconnectionPlugin::IPconnectionPlugin()
{ // no change from serial plugin
IPConnectionPlugin::IPConnectionPlugin() : m_connection(0), m_config(0)
{}
IPConnectionPlugin::~IPConnectionPlugin()
{
// manually remove the options page object
removeObject(m_connection->optionsPage());
}
IPconnectionPlugin::~IPconnectionPlugin()
{ // manually remove the options page object
removeObject(m_connection->Optionspage());
bool IPConnectionPlugin::initialize(const QStringList &arguments, QString *errorString)
{
Q_UNUSED(arguments);
Q_UNUSED(errorString);
Core::ICore::instance()->readSettings(this);
m_connection = new IPConnectionConnection(m_config);
// must manage this registration of child object ourselves
// if we use an autorelease here it causes the GCS to crash
// as it is deleting objects as the app closes...
addObject(m_connection->optionsPage());
// FIXME this is really a contrived way to save the settings...
// needs to be done centrally from
QObject::connect(m_connection, &IPConnectionConnection::availableDevChanged,
[this]() { Core::ICore::instance()->saveSettings(this); }
);
return true;
}
void IPconnectionPlugin::extensionsInitialized()
void IPConnectionPlugin::extensionsInitialized()
{
addAutoReleasedObject(m_connection);
}
bool IPconnectionPlugin::initialize(const QStringList &arguments, QString *errorString)
void IPConnectionPlugin::readConfig(QSettings &settings, Core::UAVConfigInfo *configInfo)
{
Q_UNUSED(arguments);
Q_UNUSED(errorString);
m_connection = new IPconnectionConnection();
// must manage this registration of child object ourselves
// if we use an autorelease here it causes the GCS to crash
// as it is deleting objects as the app closes...
addObject(m_connection->Optionspage());
Q_UNUSED(configInfo);
return true;
m_config = new IPConnectionConfiguration("IPConnection", settings, this);
}
void IPConnectionPlugin::saveConfig(QSettings &settings, Core::UAVConfigInfo *configInfo) const
{
Q_UNUSED(configInfo);
if (m_config) {
m_config->saveConfig(settings);
}
}

58
ground/gcs/src/plugins/ipconnection/ipconnectionplugin.h
View File

@ -1,13 +1,14 @@
/**
******************************************************************************
*
* @file IPconnectionplugin.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @file ipconnectionplugin.h
* @author The LibrePilot Project, http://www.librepilot.org Copyright (C) 2017.
* The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins
* @{
* @addtogroup IPConnPlugin IP Telemetry Plugin
* @{
* @brief IP Connection Plugin impliment telemetry over TCP/IP and UDP/IP
* @brief IP Connection Plugin implements telemetry over TCP/IP and UDP/IP
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
@ -25,15 +26,16 @@
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef IPconnectionPLUGIN_H
#define IPconnectionPLUGIN_H
#ifndef IPCONNECTIONPLUGIN_H
#define IPCONNECTIONPLUGIN_H
#include "ipconnection_global.h"
#include "ipconnectionoptionspage.h"
#include "ipconnectionconfiguration.h"
#include "coreplugin/iconnection.h"
#include <extensionsystem/iplugin.h>
// #include <QtCore/QSettings>
#include <coreplugin/iconfigurableplugin.h>
#include <coreplugin/iconnection.h>
class QAbstractSocket;
class QTcpSocket;
@ -46,12 +48,12 @@ class IConnection;
* Plugin will add a instance of this class to the pool,
* so the connection manager can use it.
*/
class IPconnection_EXPORT IPconnectionConnection : public Core::IConnection {
class IPCONNECTION_EXPORT IPConnectionConnection : public Core::IConnection {
Q_OBJECT
public:
IPconnectionConnection();
virtual ~IPconnectionConnection();
IPConnectionConnection(IPConnectionConfiguration *config);
virtual ~IPConnectionConnection();
virtual QList <Core::IConnection::device> availableDevices();
virtual QIODevice *openDevice(const QString &deviceName);
@ -60,42 +62,44 @@ public:
virtual QString connectionName();
virtual QString shortName();
IPconnectionConfiguration *Config() const
IPConnectionOptionsPage *optionsPage() const
{
return m_config;
}
IPconnectionOptionsPage *Optionspage() const
{
return m_optionspage;
return m_optionsPage;
}
protected slots:
void onEnumerationChanged();
signals: // For the benefit of IPConnection
signals:
// For the benefit of IPConnection
// FIXME change to camel case
void CreateSocket(QString HostName, int Port, bool UseTCP);
void CloseSocket(QAbstractSocket *socket);
private:
QAbstractSocket *ipSocket;
IPconnectionConfiguration *m_config;
IPconnectionOptionsPage *m_optionspage;
// QSettings* settings;
QAbstractSocket *m_ipSocket;
// FIXME m_config and m_optionsPage belong in IPConnectionPlugin
IPConnectionConfiguration *m_config;
IPConnectionOptionsPage *m_optionsPage;
};
class IPconnection_EXPORT IPconnectionPlugin : public ExtensionSystem::IPlugin {
class IPCONNECTION_EXPORT IPConnectionPlugin : public Core::IConfigurablePlugin {
Q_OBJECT
Q_PLUGIN_METADATA(IID "OpenPilot.IPconnection")
Q_PLUGIN_METADATA(IID "OpenPilot.IPConnection")
public:
IPconnectionPlugin();
~IPconnectionPlugin();
IPConnectionPlugin();
~IPConnectionPlugin();
virtual bool initialize(const QStringList &arguments, QString *error_message);
virtual void extensionsInitialized();
void readConfig(QSettings &settings, Core::UAVConfigInfo *configInfo);
void saveConfig(QSettings &settings, Core::UAVConfigInfo *configInfo) const;
private:
IPconnectionConnection *m_connection;
IPConnectionConnection *m_connection;
IPConnectionConfiguration *m_config;
};
#endif // IPconnectionPLUGIN_H
#endif // IPCONNECTIONPLUGIN_H

128
ground/gcs/src/plugins/lineardial/lineardialgadgetconfiguration.cpp
View File

@ -32,92 +32,78 @@
* Loads a saved configuration or defaults if non exist.
*
*/
LineardialGadgetConfiguration::LineardialGadgetConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent),
dialFile("Unknown"),
sourceDataObject("Unknown"),
sourceObjectField("Unknown"),
minValue(0),
maxValue(100),
redMin(0),
redMax(33),
yellowMin(33),
yellowMax(66),
greenMin(66),
greenMax(100),
factor(1.00),
decimalPlaces(0),
useOpenGLFlag(false)
LineardialGadgetConfiguration::LineardialGadgetConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
// if a saved configuration exists load it
if (qSettings != 0) {
QString dFile = qSettings->value("dFile").toString();
dialFile = Utils::InsertDataPath(dFile);
sourceDataObject = qSettings->value("sourceDataObject").toString();
sourceObjectField = qSettings->value("sourceObjectField").toString();
minValue = qSettings->value("minValue").toDouble();
maxValue = qSettings->value("maxValue").toDouble();
redMin = qSettings->value("redMin").toDouble();
redMax = qSettings->value("redMax").toDouble();
yellowMin = qSettings->value("yellowMin").toDouble();
yellowMax = qSettings->value("yellowMax").toDouble();
greenMin = qSettings->value("greenMin").toDouble();
greenMax = qSettings->value("greenMax").toDouble();
font = qSettings->value("font").toString();
decimalPlaces = qSettings->value("decimalPlaces").toInt();
factor = qSettings->value("factor").toDouble();
useOpenGLFlag = qSettings->value("useOpenGLFlag").toBool();
}
QString dFile = settings.value("dFile").toString();
dialFile = Utils::InsertDataPath(dFile);
sourceDataObject = settings.value("sourceDataObject", "Unknown").toString();
sourceObjectField = settings.value("sourceObjectField", "Unknown").toString();
minValue = settings.value("minValue", 0).toDouble();
maxValue = settings.value("maxValue", 100).toDouble();
redMin = settings.value("redMin", 0).toDouble();
redMax = settings.value("redMax", 33).toDouble();
yellowMin = settings.value("yellowMin", 33).toDouble();
yellowMax = settings.value("yellowMax", 66).toDouble();
greenMin = settings.value("greenMin", 66).toDouble();
greenMax = settings.value("greenMax", 100).toDouble();
font = settings.value("font").toString();
decimalPlaces = settings.value("decimalPlaces", 0).toInt();
factor = settings.value("factor", 1.0).toDouble();
useOpenGLFlag = settings.value("useOpenGLFlag").toBool();
}
LineardialGadgetConfiguration::LineardialGadgetConfiguration(const LineardialGadgetConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
dialFile = obj.dialFile;
sourceDataObject = obj.sourceDataObject;
sourceObjectField = obj.sourceObjectField;
minValue = obj.minValue;
maxValue = obj.maxValue;
redMin = obj.redMin;
redMax = obj.redMax;
yellowMin = obj.yellowMin;
yellowMax = obj.yellowMax;
greenMin = obj.greenMin;
greenMax = obj.greenMax;
font = obj.font;
decimalPlaces = obj.decimalPlaces;
factor = obj.factor;
useOpenGLFlag = obj.useOpenGLFlag;
}
/**
* Clones a configuration.
*
*/
IUAVGadgetConfiguration *LineardialGadgetConfiguration::clone()
IUAVGadgetConfiguration *LineardialGadgetConfiguration::clone() const
{
LineardialGadgetConfiguration *m = new LineardialGadgetConfiguration(this->classId());
m->dialFile = dialFile;
m->sourceDataObject = sourceDataObject;
m->sourceObjectField = sourceObjectField;
m->minValue = minValue;
m->maxValue = maxValue;
m->redMin = redMin;
m->redMax = redMax;
m->yellowMin = yellowMin;
m->yellowMax = yellowMax;
m->greenMin = greenMin;
m->greenMax = greenMax;
m->font = font;
m->decimalPlaces = decimalPlaces;
m->factor = factor;
m->useOpenGLFlag = useOpenGLFlag;
return m;
return new LineardialGadgetConfiguration(*this);
}
/**
* Saves a configuration.
*
*/
void LineardialGadgetConfiguration::saveConfig(QSettings *qSettings) const
void LineardialGadgetConfiguration::saveConfig(QSettings &settings) const
{
QString dFile = Utils::RemoveDataPath(dialFile);
qSettings->setValue("dFile", dFile);
qSettings->setValue("sourceDataObject", sourceDataObject);
qSettings->setValue("sourceObjectField", sourceObjectField);
qSettings->setValue("minValue", minValue);
qSettings->setValue("maxValue", maxValue);
qSettings->setValue("redMin", redMin);
qSettings->setValue("redMax", redMax);
qSettings->setValue("yellowMin", yellowMin);
qSettings->setValue("yellowMax", yellowMax);
qSettings->setValue("greenMin", greenMin);
qSettings->setValue("greenMax", greenMax);
qSettings->setValue("font", font);
qSettings->setValue("decimalPlaces", decimalPlaces);
qSettings->setValue("factor", factor);
qSettings->setValue("useOpenGLFlag", useOpenGLFlag);
settings.setValue("dFile", dFile);
settings.setValue("sourceDataObject", sourceDataObject);
settings.setValue("sourceObjectField", sourceObjectField);
settings.setValue("minValue", minValue);
settings.setValue("maxValue", maxValue);
settings.setValue("redMin", redMin);
settings.setValue("redMax", redMax);
settings.setValue("yellowMin", yellowMin);
settings.setValue("yellowMax", yellowMax);
settings.setValue("greenMin", greenMin);
settings.setValue("greenMax", greenMax);
settings.setValue("font", font);
settings.setValue("decimalPlaces", decimalPlaces);
settings.setValue("factor", factor);
settings.setValue("useOpenGLFlag", useOpenGLFlag);
}

13
ground/gcs/src/plugins/lineardial/lineardialgadgetconfiguration.h
View File

@ -38,7 +38,11 @@ using namespace Core;
class LineardialGadgetConfiguration : public IUAVGadgetConfiguration {
Q_OBJECT
public:
explicit LineardialGadgetConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit LineardialGadgetConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit LineardialGadgetConfiguration(const LineardialGadgetConfiguration &obj);
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
// set dial configuration functions
void setDialFile(QString filename)
@ -61,12 +65,10 @@ public:
{
redMin = min; redMax = max;
}
void setFont(QString text)
{
font = text;
}
void setFactor(double val)
{
factor = val;
@ -75,7 +77,6 @@ public:
{
decimalPlaces = val;
}
void setSourceDataObject(QString text)
{
sourceDataObject = text;
@ -84,7 +85,6 @@ public:
{
sourceObjectField = text;
}
void setUseOpenGL(bool flag)
{
useOpenGLFlag = flag;
@ -152,9 +152,6 @@ public:
return useOpenGLFlag;
}
void saveConfig(QSettings *settings) const;
IUAVGadgetConfiguration *clone();
private:
// A linear or "bargraph" dial contains:
// * A SVG background file

4
ground/gcs/src/plugins/lineardial/lineardialgadgetfactory.cpp
View File

@ -47,9 +47,9 @@ Core::IUAVGadget *LineardialGadgetFactory::createGadget(QWidget *parent)
return new LineardialGadget(QString("LineardialGadget"), gadgetWidget, parent);
}
IUAVGadgetConfiguration *LineardialGadgetFactory::createConfiguration(QSettings *qSettings)
IUAVGadgetConfiguration *LineardialGadgetFactory::createConfiguration(QSettings &settings)
{
return new LineardialGadgetConfiguration(QString("LineardialGadget"), qSettings);
return new LineardialGadgetConfiguration(QString("LineardialGadget"), settings);
}
IOptionsPage *LineardialGadgetFactory::createOptionsPage(IUAVGadgetConfiguration *config)

2
ground/gcs/src/plugins/lineardial/lineardialgadgetfactory.h
View File

@ -44,7 +44,7 @@ public:
~LineardialGadgetFactory();
Core::IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(QSettings *qSettings);
IUAVGadgetConfiguration *createConfiguration(QSettings &settings);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};

62
ground/gcs/src/plugins/notify/notificationitem.cpp
View File

@ -104,42 +104,42 @@ void NotificationItem::copyTo(NotificationItem *that) const
}
void NotificationItem::saveState(QSettings *settings) const
void NotificationItem::saveState(QSettings &settings) const
{
settings->setValue("SoundCollectionPath", Utils::RemoveDataPath(getSoundCollectionPath()));
settings->setValue(QLatin1String("CurrentLanguage"), getCurrentLanguage());
settings->setValue(QLatin1String("ObjectField"), getObjectField());
settings->setValue(QLatin1String("DataObject"), getDataObject());
settings->setValue(QLatin1String("RangeLimit"), getCondition());
settings->setValue(QLatin1String("Value1"), singleValue());
settings->setValue(QLatin1String("Value2"), valueRange2());
settings->setValue(QLatin1String("Sound1"), getSound1());
settings->setValue(QLatin1String("Sound2"), getSound2());
settings->setValue(QLatin1String("Sound3"), getSound3());
settings->setValue(QLatin1String("SayOrder"), getSayOrder());
settings->setValue(QLatin1String("Repeat"), retryValue());
settings->setValue(QLatin1String("ExpireTimeout"), lifetime());
settings->setValue(QLatin1String("Mute"), mute());
settings.setValue("SoundCollectionPath", Utils::RemoveDataPath(getSoundCollectionPath()));
settings.setValue(QLatin1String("CurrentLanguage"), getCurrentLanguage());
settings.setValue(QLatin1String("ObjectField"), getObjectField());
settings.setValue(QLatin1String("DataObject"), getDataObject());
settings.setValue(QLatin1String("RangeLimit"), getCondition());
settings.setValue(QLatin1String("Value1"), singleValue());
settings.setValue(QLatin1String("Value2"), valueRange2());
settings.setValue(QLatin1String("Sound1"), getSound1());
settings.setValue(QLatin1String("Sound2"), getSound2());
settings.setValue(QLatin1String("Sound3"), getSound3());
settings.setValue(QLatin1String("SayOrder"), getSayOrder());
settings.setValue(QLatin1String("Repeat"), retryValue());
settings.setValue(QLatin1String("ExpireTimeout"), lifetime());
settings.setValue(QLatin1String("Mute"), mute());
}
void NotificationItem::restoreState(QSettings *settings)
void NotificationItem::restoreState(QSettings &settings)
{
// settings = Core::ICore::instance()->settings();
setSoundCollectionPath(Utils::InsertDataPath(settings->value(QLatin1String("SoundCollectionPath"), tr("")).toString()));
setCurrentLanguage(settings->value(QLatin1String("CurrentLanguage"), tr("")).toString());
setDataObject(settings->value(QLatin1String("DataObject"), tr("")).toString());
setObjectField(settings->value(QLatin1String("ObjectField"), tr("")).toString());
setCondition(settings->value(QLatin1String("RangeLimit"), tr("")).toInt());
setSound1(settings->value(QLatin1String("Sound1"), tr("")).toString());
setSound2(settings->value(QLatin1String("Sound2"), tr("")).toString());
setSound3(settings->value(QLatin1String("Sound3"), tr("")).toString());
setSayOrder(settings->value(QLatin1String("SayOrder"), tr("")).toInt());
QVariant value = settings->value(QLatin1String("Value1"), tr(""));
setSoundCollectionPath(Utils::InsertDataPath(settings.value(QLatin1String("SoundCollectionPath"), tr("")).toString()));
setCurrentLanguage(settings.value(QLatin1String("CurrentLanguage"), tr("")).toString());
setDataObject(settings.value(QLatin1String("DataObject"), tr("")).toString());
setObjectField(settings.value(QLatin1String("ObjectField"), tr("")).toString());
setCondition(settings.value(QLatin1String("RangeLimit"), tr("")).toInt());
setSound1(settings.value(QLatin1String("Sound1"), tr("")).toString());
setSound2(settings.value(QLatin1String("Sound2"), tr("")).toString());
setSound3(settings.value(QLatin1String("Sound3"), tr("")).toString());
setSayOrder(settings.value(QLatin1String("SayOrder"), tr("")).toInt());
QVariant value = settings.value(QLatin1String("Value1"), tr(""));
setSingleValue(value);
setValueRange2(settings->value(QLatin1String("Value2"), tr("")).toDouble());
setRetryValue(settings->value(QLatin1String("Repeat"), tr("")).toInt());
setLifetime(settings->value(QLatin1String("ExpireTimeout"), tr("")).toInt());
setMute(settings->value(QLatin1String("Mute"), tr("")).toInt());
setValueRange2(settings.value(QLatin1String("Value2"), tr("")).toDouble());
setRetryValue(settings.value(QLatin1String("Repeat"), tr("")).toInt());
setLifetime(settings.value(QLatin1String("ExpireTimeout"), tr("")).toInt());
setMute(settings.value(QLatin1String("Mute"), tr("")).toInt());
}
void NotificationItem::serialize(QDataStream & stream)
@ -149,7 +149,7 @@ void NotificationItem::serialize(QDataStream & stream)
stream << this->_dataObject;
stream << this->_objectField;
stream << this->_condition;
qNotifyDebug() << "getOptionsPageValues seriaize" << _condition;
qNotifyDebug() << "getOptionsPageValues serialize" << _condition;
stream << this->_sound1;
stream << this->_sound2;
stream << this->_sound3;

7
ground/gcs/src/plugins/notify/notificationitem.h
View File

@ -177,9 +177,8 @@ public:
_mute = value;
}
void saveState(QSettings *settings) const;
void restoreState(QSettings *settings);
void saveState(QSettings &settings) const;
void restoreState(QSettings &settings);
UAVDataObject *getUAVObject(void);
UAVObjectField *getUAVObjectField(void);
@ -208,7 +207,7 @@ public:
* Returns sound caption name, needed to create string representation of notification.
*
* @return success - string == <sound filename>, if sound file exists
* error - string == [missind]<sound filename>, if sound file doesn't exist
* error - string == [missing]<sound filename>, if sound file doesn't exist
*/
QString getSoundCaption(QString fileName);

38
ground/gcs/src/plugins/notify/notifyplugin.cpp
View File

@ -81,48 +81,48 @@ void SoundNotifyPlugin::extensionsInitialized()
connectNotifications();
}
void SoundNotifyPlugin::saveConfig(QSettings *settings, UAVConfigInfo *configInfo)
void SoundNotifyPlugin::saveConfig(QSettings &settings, UAVConfigInfo *configInfo) const
{
configInfo->setVersion(VERSION);
settings->beginWriteArray("Current");
settings->setArrayIndex(0);
settings.beginWriteArray("Current");
settings.setArrayIndex(0);
currentNotification.saveState(settings);
settings->endArray();
settings.endArray();
settings->beginGroup("listNotifies");
settings->remove("");
settings->endGroup();
settings.beginGroup("listNotifies");
settings.remove("");
settings.endGroup();
settings->beginWriteArray("listNotifies");
settings.beginWriteArray("listNotifies");
for (int i = 0; i < _notificationList.size(); i++) {
settings->setArrayIndex(i);
settings.setArrayIndex(i);
_notificationList.at(i)->saveState(settings);
}
settings->endArray();
settings->setValue(QLatin1String("EnableSound"), enableSound);
settings.endArray();
settings.setValue(QLatin1String("EnableSound"), enableSound);
}
void SoundNotifyPlugin::readConfig(QSettings *settings, UAVConfigInfo * /* configInfo */)
void SoundNotifyPlugin::readConfig(QSettings &settings, UAVConfigInfo * /* configInfo */)
{
// Just for migration to the new format.
// Q_ASSERT(configInfo->version() == UAVConfigVersion());
settings->beginReadArray("Current");
settings->setArrayIndex(0);
settings.beginReadArray("Current");
settings.setArrayIndex(0);
currentNotification.restoreState(settings);
settings->endArray();
settings.endArray();
// read list of notifications from settings
int size = settings->beginReadArray("listNotifies");
int size = settings.beginReadArray("listNotifies");
for (int i = 0; i < size; ++i) {
settings->setArrayIndex(i);
settings.setArrayIndex(i);
NotificationItem *notification = new NotificationItem;
notification->restoreState(settings);
_notificationList.append(notification);
}
settings->endArray();
setEnableSound(settings->value(QLatin1String("EnableSound"), 0).toBool());
settings.endArray();
setEnableSound(settings.value(QLatin1String("EnableSound"), 0).toBool());
}
void SoundNotifyPlugin::onTelemetryManagerAdded(QObject *obj)

4
ground/gcs/src/plugins/notify/notifyplugin.h
View File

@ -56,8 +56,8 @@ public:
void extensionsInitialized();
bool initialize(const QStringList & arguments, QString *errorString);
void readConfig(QSettings *qSettings, Core::UAVConfigInfo *configInfo);
void saveConfig(QSettings *qSettings, Core::UAVConfigInfo *configInfo);
void readConfig(QSettings &settings, Core::UAVConfigInfo *configInfo);
void saveConfig(QSettings &settings, Core::UAVConfigInfo *configInfo) const;
void shutdown();

57
ground/gcs/src/plugins/notify/notifypluginfactory.cpp
View File

@ -1,57 +0,0 @@
/**
******************************************************************************
*
* @file notifypluginfactory.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup notifyplugin
* @{
*
*****************************************************************************/
/*
* 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
*/
#include "notifypluginfactory.h"
// #include "notifypluginwidget.h"
#include "notifyplugin.h"
#include "notifypluginconfiguration.h"
#include "notifypluginoptionspage.h"
#include <coreplugin/iuavgadget.h>
NotifyPluginFactory::NotifyPluginFactory(QObject *parent) :
IUAVGadgetFactory(QString("Notify Plugin"),
tr("Notify Plugin"),
parent)
{}
NotifyPluginFactory::~NotifyPluginFactory()
{}
Core::IUAVGadget *NotifyPluginFactory::createGadget(QWidget *parent)
{
// NotifyPluginWidget* gadgetWidget = new NotifyPluginWidget(parent);
return (Core::IUAVGadget *)0; // new NotifyPlugin(QString("NotifyPlugin"), gadgetWidget, parent);
}
IUAVGadgetConfiguration *NotifyPluginFactory::createConfiguration(const QByteArray &state)
{
return new NotifyPluginConfiguration(QString("Notify Plugin"), state);
}
IOptionsPage *NotifyPluginFactory::createOptionsPage(IUAVGadgetConfiguration *config)
{
return new NotifyPluginOptionsPage(qobject_cast<NotifyPluginConfiguration *>(config));
}

52
ground/gcs/src/plugins/notify/notifypluginfactory.h
View File

@ -1,52 +0,0 @@
/**
******************************************************************************
*
* @file notifypluginfactory.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup notifyplugin
* @{
*
*****************************************************************************/
/*
* 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
*/
#ifndef NOTIFYPLUGINFACTORY_H
#define NOTIFYPLUGINFACTORY_H
#include <coreplugin/iuavgadgetfactory.h>
namespace Core {
class IUAVGadget;
class IUAVGadgetFactory;
}
using namespace Core;
class NotifyPluginFactory : public IUAVGadgetFactory {
Q_OBJECT
public:
NotifyPluginFactory(QObject *parent = 0);
~NotifyPluginFactory();
Core::IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(const QByteArray &state);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};
#endif // NOTIFYPLUGINFACTORY_H

55
ground/gcs/src/plugins/notify/notifyplugingadget.h
View File

@ -1,55 +0,0 @@
/**
******************************************************************************
*
* @file notifyplugingadget.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup notifyplugin
* @{
*
*****************************************************************************/
/*
* 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
*/
#ifndef NOTIFYPLUGINGADGET_H
#define NOTIFYPLUGINGADGET_H
#include <coreplugin/iuavgadget.h>
// #include "NotifyPlugingadgetwidget.h"
class IUAVGadget;
class QWidget;
class QString;
// class NotifyPluginGadgetWidget;
using namespace Core;
class NotifyPluginGadget : public Core::IUAVGadget {
Q_OBJECT
public:
NotifyPluginGadget(QString classId, NotifyPluginGadgetWidget *widget, QWidget *parent = 0);
~NotifyPluginGadget();
// QWidget *widget() { return m_widget; }
void loadConfiguration(IUAVGadgetConfiguration *config);
private:
// NotifyPluginGadgetWidget *m_widget;
};
#endif // NOTIFYPLUGINGADGET_H

1
ground/gcs/src/plugins/notify/notifypluginoptionspage.cpp
View File

@ -35,7 +35,6 @@
#include <QFileDialog>
#include <QtAlgorithms>
#include <QStringList>
#include <QtCore/QSettings>
#include <QTableWidget>
#include <QPalette>
#include <QBuffer>

154
ground/gcs/src/plugins/opmap/opmapgadgetconfiguration.cpp
View File

@ -29,112 +29,80 @@
#include "utils/pathutils.h"
#include <QDir>
OPMapGadgetConfiguration::OPMapGadgetConfiguration(QString classId, QSettings *qSettings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent),
m_mapProvider("GoogleHybrid"),
m_defaultZoom(2),
m_defaultLatitude(0),
m_defaultLongitude(0),
m_useOpenGL(false),
m_showTileGridLines(false),
m_accessMode("ServerAndCache"),
m_useMemoryCache(true),
m_cacheLocation(Utils::GetStoragePath() + "mapscache" + QDir::separator()),
m_uavSymbol(QString::fromUtf8(":/uavs/images/mapquad.png")),
m_maxUpdateRate(2000), // ms
m_settings(qSettings),
m_opacity(1),
m_defaultWaypointAltitude(15),
m_defaultWaypointVelocity(2)
OPMapGadgetConfiguration::OPMapGadgetConfiguration(QString classId, QSettings &settings, QObject *parent) :
IUAVGadgetConfiguration(classId, parent)
{
// if a saved configuration exists load it
if (qSettings != 0) {
QString mapProvider = qSettings->value("mapProvider").toString();
int zoom = qSettings->value("defaultZoom").toInt();
double latitude = qSettings->value("defaultLatitude").toDouble();
double longitude = qSettings->value("defaultLongitude").toDouble();
bool useOpenGL = qSettings->value("useOpenGL").toBool();
bool showTileGridLines = qSettings->value("showTileGridLines").toBool();
QString accessMode = qSettings->value("accessMode").toString();
bool useMemoryCache = qSettings->value("useMemoryCache").toBool();
QString cacheLocation = qSettings->value("cacheLocation").toString();
QString uavSymbol = qSettings->value("uavSymbol").toString();
int max_update_rate = qSettings->value("maxUpdateRate").toInt();
m_defaultWaypointAltitude = qSettings->value("defaultWaypointAltitude", 15).toReal();
m_defaultWaypointVelocity = qSettings->value("defaultWaypointVelocity", 2).toReal();
m_opacity = qSettings->value("overlayOpacity", 1).toReal();
m_defaultWaypointAltitude = settings.value("defaultWaypointAltitude", 15).toReal();
m_defaultWaypointVelocity = settings.value("defaultWaypointVelocity", 2).toReal();
m_opacity = settings.value("overlayOpacity", 1).toReal();
if (!mapProvider.isEmpty()) {
m_mapProvider = mapProvider;
}
m_defaultZoom = zoom;
m_defaultLatitude = latitude;
m_defaultLongitude = longitude;
m_useOpenGL = useOpenGL;
m_showTileGridLines = showTileGridLines;
m_uavSymbol = uavSymbol;
m_mapProvider = settings.value("mapProvider", "GoogleHybrid").toString();
m_defaultZoom = settings.value("defaultZoom", 2).toInt();
m_defaultLatitude = settings.value("defaultLatitude").toDouble();
m_defaultLongitude = settings.value("defaultLongitude").toDouble();
m_useOpenGL = settings.value("useOpenGL").toBool();
m_showTileGridLines = settings.value("showTileGridLines").toBool();
m_uavSymbol = settings.value("uavSymbol", QString::fromUtf8(":/uavs/images/mapquad.png")).toString();
m_maxUpdateRate = max_update_rate;
if (m_maxUpdateRate < 100 || m_maxUpdateRate > 5000) {
m_maxUpdateRate = 2000;
}
if (!accessMode.isEmpty()) {
m_accessMode = accessMode;
}
m_useMemoryCache = useMemoryCache;
if (!cacheLocation.isEmpty()) {
m_cacheLocation = Utils::InsertStoragePath(cacheLocation);
}
m_maxUpdateRate = settings.value("maxUpdateRate", 2000).toInt();
if (m_maxUpdateRate < 100 || m_maxUpdateRate > 5000) {
m_maxUpdateRate = 2000;
}
m_accessMode = settings.value("accessMode", "ServerAndCache").toString();
m_useMemoryCache = settings.value("useMemoryCache").toBool();
m_cacheLocation = settings.value("cacheLocation", Utils::GetStoragePath() + "mapscache" + QDir::separator()).toString();
m_cacheLocation = Utils::InsertStoragePath(m_cacheLocation);
}
IUAVGadgetConfiguration *OPMapGadgetConfiguration::clone()
OPMapGadgetConfiguration::OPMapGadgetConfiguration(const OPMapGadgetConfiguration &obj) :
IUAVGadgetConfiguration(obj.classId(), obj.parent())
{
OPMapGadgetConfiguration *m = new OPMapGadgetConfiguration(this->classId());
m->m_mapProvider = m_mapProvider;
m->m_defaultZoom = m_defaultZoom;
m->m_defaultLatitude = m_defaultLatitude;
m->m_defaultLongitude = m_defaultLongitude;
m->m_useOpenGL = m_useOpenGL;
m->m_showTileGridLines = m_showTileGridLines;
m->m_accessMode = m_accessMode;
m->m_useMemoryCache = m_useMemoryCache;
m->m_cacheLocation = m_cacheLocation;
m->m_uavSymbol = m_uavSymbol;
m->m_maxUpdateRate = m_maxUpdateRate;
m->m_opacity = m_opacity;
m->m_defaultWaypointAltitude = m_defaultWaypointAltitude;
m->m_defaultWaypointVelocity = m_defaultWaypointVelocity;
return m;
m_mapProvider = obj.m_mapProvider;
m_defaultZoom = obj.m_defaultZoom;
m_defaultLatitude = obj.m_defaultLatitude;
m_defaultLongitude = obj.m_defaultLongitude;
m_useOpenGL = obj.m_useOpenGL;
m_showTileGridLines = obj.m_showTileGridLines;
m_accessMode = obj.m_accessMode;
m_useMemoryCache = obj.m_useMemoryCache;
m_cacheLocation = obj.m_cacheLocation;
m_uavSymbol = obj.m_uavSymbol;
m_maxUpdateRate = obj.m_maxUpdateRate;
m_opacity = obj.m_opacity;
m_defaultWaypointAltitude = obj.m_defaultWaypointAltitude;
m_defaultWaypointVelocity = obj.m_defaultWaypointVelocity;
}
IUAVGadgetConfiguration *OPMapGadgetConfiguration::clone() const
{
return new OPMapGadgetConfiguration(*this);
}
void OPMapGadgetConfiguration::save() const
{
if (!m_settings) {
return;
}
QSettings settings;
saveConfig(m_settings);
saveConfig(settings);
}
void OPMapGadgetConfiguration::saveConfig(QSettings *qSettings) const
{
qSettings->setValue("mapProvider", m_mapProvider);
qSettings->setValue("defaultZoom", m_defaultZoom);
qSettings->setValue("defaultLatitude", m_defaultLatitude);
qSettings->setValue("defaultLongitude", m_defaultLongitude);
qSettings->setValue("useOpenGL", m_useOpenGL);
qSettings->setValue("showTileGridLines", m_showTileGridLines);
qSettings->setValue("accessMode", m_accessMode);
qSettings->setValue("useMemoryCache", m_useMemoryCache);
qSettings->setValue("uavSymbol", m_uavSymbol);
qSettings->setValue("cacheLocation", Utils::RemoveStoragePath(m_cacheLocation));
qSettings->setValue("maxUpdateRate", m_maxUpdateRate);
qSettings->setValue("overlayOpacity", m_opacity);
qSettings->setValue("defaultWaypointAltitude", m_defaultWaypointAltitude);
qSettings->setValue("defaultWaypointVelocity", m_defaultWaypointVelocity);
void OPMapGadgetConfiguration::saveConfig(QSettings &settings) const
{
settings.setValue("mapProvider", m_mapProvider);
settings.setValue("defaultZoom", m_defaultZoom);
settings.setValue("defaultLatitude", m_defaultLatitude);
settings.setValue("defaultLongitude", m_defaultLongitude);
settings.setValue("useOpenGL", m_useOpenGL);
settings.setValue("showTileGridLines", m_showTileGridLines);
settings.setValue("accessMode", m_accessMode);
settings.setValue("useMemoryCache", m_useMemoryCache);
settings.setValue("uavSymbol", m_uavSymbol);
settings.setValue("cacheLocation", Utils::RemoveStoragePath(m_cacheLocation));
settings.setValue("maxUpdateRate", m_maxUpdateRate);
settings.setValue("overlayOpacity", m_opacity);
settings.setValue("defaultWaypointAltitude", m_defaultWaypointAltitude);
settings.setValue("defaultWaypointVelocity", m_defaultWaypointVelocity);
}
void OPMapGadgetConfiguration::setCacheLocation(QString cacheLocation)
{

14
ground/gcs/src/plugins/opmap/opmapgadgetconfiguration.h
View File

@ -29,7 +29,8 @@
#define OPMAP_GADGETCONFIGURATION_H
#include <coreplugin/iuavgadgetconfiguration.h>
#include <QtCore/QString>
#include <QString>
using namespace Core;
@ -50,10 +51,13 @@ class OPMapGadgetConfiguration : public IUAVGadgetConfiguration {
Q_PROPERTY(qreal defaultWaypointVelocity READ defaultWaypointVelocity WRITE setDefaultWaypointVelocity)
public:
explicit OPMapGadgetConfiguration(QString classId, QSettings *qSettings = 0, QObject *parent = 0);
explicit OPMapGadgetConfiguration(QString classId, QSettings &settings, QObject *parent = 0);
explicit OPMapGadgetConfiguration(const OPMapGadgetConfiguration &obj);
void saveConfig(QSettings *settings) const;
IUAVGadgetConfiguration *clone();
IUAVGadgetConfiguration *clone() const;
void saveConfig(QSettings &settings) const;
void save() const;
QString mapProvider() const
{
@ -114,7 +118,6 @@ public:
return m_defaultWaypointVelocity;
}
void save() const;
public slots:
void setMapProvider(QString provider)
{
@ -184,7 +187,6 @@ private:
QString m_cacheLocation;
QString m_uavSymbol;
int m_maxUpdateRate;
QSettings *m_settings;
qreal m_opacity;
qreal m_defaultWaypointAltitude;
qreal m_defaultWaypointVelocity;

4
ground/gcs/src/plugins/opmap/opmapgadgetfactory.cpp
View File

@ -45,9 +45,9 @@ Core::IUAVGadget *OPMapGadgetFactory::createGadget(QWidget *parent)
return new OPMapGadget(QString("OPMapGadget"), gadgetWidget, parent);
}
IUAVGadgetConfiguration *OPMapGadgetFactory::createConfiguration(QSettings *qSettings)
IUAVGadgetConfiguration *OPMapGadgetFactory::createConfiguration(QSettings &settings)
{
return new OPMapGadgetConfiguration(QString("OPMapGadget"), qSettings);
return new OPMapGadgetConfiguration(QString("OPMapGadget"), settings);
}
IOptionsPage *OPMapGadgetFactory::createOptionsPage(IUAVGadgetConfiguration *config)

2
ground/gcs/src/plugins/opmap/opmapgadgetfactory.h
View File

@ -45,7 +45,7 @@ public:
~OPMapGadgetFactory();
Core::IUAVGadget *createGadget(QWidget *parent);
IUAVGadgetConfiguration *createConfiguration(QSettings *qSettings);
IUAVGadgetConfiguration *createConfiguration(QSettings &settings);
IOptionsPage *createOptionsPage(IUAVGadgetConfiguration *config);
};

8
ground/gcs/src/plugins/pfdqml/pfdqmlcontext.cpp
View File

@ -310,14 +310,14 @@ void PfdQmlContext::loadConfiguration(PfdQmlGadgetConfiguration *config)
}
void PfdQmlContext::saveState(QSettings *settings)
void PfdQmlContext::saveState(QSettings &settings) const
{
settings->setValue("modelFile", modelFile());
settings.setValue("modelFile", modelFile());
}
void PfdQmlContext::restoreState(QSettings *settings)
void PfdQmlContext::restoreState(QSettings &settings)
{
QString file = settings->value("modelFile").toString();
QString file = settings.value("modelFile").toString();
if (!file.isEmpty()) {
setModelFile(file);

4
ground/gcs/src/plugins/pfdqml/pfdqmlcontext.h
View File

@ -105,8 +105,8 @@ public:
Q_INVOKABLE void resetConsumedEnergy();
void loadConfiguration(PfdQmlGadgetConfiguration *config);
void saveState(QSettings *);
void restoreState(QSettings *);
void saveState(QSettings &) const;
void restoreState(QSettings &);
void apply(QQmlContext *context);

4
ground/gcs/src/plugins/pfdqml/pfdqmlgadget.cpp
View File

@ -52,12 +52,12 @@ void PfdQmlGadget::loadConfiguration(IUAVGadgetConfiguration *config)
m_qmlGadgetWidget->loadConfiguration(m);
}
void PfdQmlGadget::saveState(QSettings *settings)
void PfdQmlGadget::saveState(QSettings &settings) const
{
m_qmlGadgetWidget->saveState(settings);
}
void PfdQmlGadget::restoreState(QSettings *settings)
void PfdQmlGadget::restoreState(QSettings &settings)
{
m_qmlGadgetWidget->restoreState(settings);
}

4
ground/gcs/src/plugins/pfdqml/pfdqmlgadget.h
View File

@ -46,8 +46,8 @@ public:
QWidget *widget();
void loadConfiguration(IUAVGadgetConfiguration *config);
void saveState(QSettings *);
void restoreState(QSettings *);
void saveState(QSettings &) const;
void restoreState(QSettings &);
private:
PfdQmlGadgetWidget *m_qmlGadgetWidget;

Some files were not shown because too many files have changed in this diff Show More