mirror of
https://github.com/swift-project/pilotclient.git
synced 2026-03-23 07:15:35 +08:00
443 lines
20 KiB
C++
443 lines
20 KiB
C++
/* Copyright (C) 2016
|
|
* swift project community / contributors
|
|
*
|
|
* This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
|
|
* directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
|
|
* including this file, may be copied, modified, propagated, or distributed except according to the terms
|
|
* contained in the LICENSE file.
|
|
*/
|
|
|
|
#include "settingssimulator.h"
|
|
#include "blackmisc/simulation/simulatedaircraft.h"
|
|
#include "blackmisc/simulation/fscommon/fscommonutil.h"
|
|
#include "blackmisc/simulation/xplane/xplaneutil.h"
|
|
#include "blackmisc/stringutils.h"
|
|
|
|
using namespace BlackMisc;
|
|
using namespace BlackMisc::PhysicalQuantities;
|
|
using namespace BlackMisc::Simulation::FsCommon;
|
|
using namespace BlackMisc::Simulation::XPlane;
|
|
|
|
namespace BlackMisc
|
|
{
|
|
namespace Simulation
|
|
{
|
|
namespace Settings
|
|
{
|
|
CSettingsSimulator::CSettingsSimulator()
|
|
{ }
|
|
|
|
void CSettingsSimulator::setSimulatorDirectory(const QString &simulatorDirectory)
|
|
{
|
|
this->m_simulatorDirectory = simulatorDirectory.trimmed();
|
|
}
|
|
|
|
const QString &CSettingsSimulator::getSimulatorDirectory() const
|
|
{
|
|
return this->m_simulatorDirectory;
|
|
}
|
|
|
|
void CSettingsSimulator::setModelDirectories(const QStringList &modelDirectories)
|
|
{
|
|
this->m_modelDirectories = modelDirectories;
|
|
}
|
|
|
|
void CSettingsSimulator::setModelDirectory(const QString &modelDirectory)
|
|
{
|
|
this->m_modelDirectories = QStringList({ modelDirectory });
|
|
}
|
|
|
|
const QStringList &CSettingsSimulator::getModelDirectories() const
|
|
{
|
|
return this->m_modelDirectories;
|
|
}
|
|
|
|
void CSettingsSimulator::setModelExcludeDirectories(const QStringList &excludeDirectories)
|
|
{
|
|
this->m_excludeDirectoryPatterns = excludeDirectories;
|
|
}
|
|
|
|
const QStringList &CSettingsSimulator::getModelExcludeDirectoryPatterns() const
|
|
{
|
|
return m_excludeDirectoryPatterns;
|
|
}
|
|
|
|
void CSettingsSimulator::resetPaths()
|
|
{
|
|
this->m_excludeDirectoryPatterns.clear();
|
|
this->m_modelDirectories.clear();
|
|
this->m_simulatorDirectory.clear();
|
|
}
|
|
|
|
QString CSettingsSimulator::convertToQString(bool i18n) const
|
|
{
|
|
return convertToQString(", ", i18n);
|
|
}
|
|
|
|
QString CSettingsSimulator::convertToQString(const QString &separator, bool i18n) const
|
|
{
|
|
Q_UNUSED(i18n);
|
|
QString s("model directories: ");
|
|
s.append(this->m_modelDirectories.join(','));
|
|
s.append(separator);
|
|
s.append("exclude directories: ");
|
|
s.append(this->m_excludeDirectoryPatterns.join(','));
|
|
return s;
|
|
}
|
|
|
|
CVariant CSettingsSimulator::propertyByIndex(const CPropertyIndex &index) const
|
|
{
|
|
if (index.isMyself()) { return CVariant::from(*this); }
|
|
ColumnIndex i = index.frontCasted<ColumnIndex>();
|
|
switch (i)
|
|
{
|
|
case IndexSimulatorDirectory:
|
|
return CVariant::fromValue(this->m_simulatorDirectory);
|
|
case IndexModelDirectory:
|
|
return CVariant::fromValue(this->m_modelDirectories);
|
|
case IndexModelExcludeDirectoryPatterns:
|
|
return CVariant::fromValue(this->m_excludeDirectoryPatterns);
|
|
default:
|
|
return CValueObject::propertyByIndex(index);
|
|
}
|
|
}
|
|
|
|
void CSettingsSimulator::setPropertyByIndex(const CPropertyIndex &index, const CVariant &variant)
|
|
{
|
|
if (index.isMyself()) { (*this) = variant.to<CSettingsSimulator>(); return; }
|
|
|
|
ColumnIndex i = index.frontCasted<ColumnIndex>();
|
|
switch (i)
|
|
{
|
|
case IndexSimulatorDirectory:
|
|
this->setSimulatorDirectory(variant.toQString());
|
|
break;
|
|
case IndexModelDirectory:
|
|
this->setSimulatorDirectory(variant.toQString());
|
|
break;
|
|
case IndexModelExcludeDirectoryPatterns:
|
|
this->m_excludeDirectoryPatterns = variant.value<QStringList>();
|
|
break;
|
|
default:
|
|
CValueObject::setPropertyByIndex(index, variant);
|
|
break;
|
|
}
|
|
}
|
|
|
|
CMultiSimulatorSimulatorSettings::CMultiSimulatorSimulatorSettings(QObject *parent) : QObject(parent)
|
|
{
|
|
// void
|
|
}
|
|
|
|
CSettingsSimulator CMultiSimulatorSimulatorSettings::getSettings(const CSimulatorInfo &simulator) const
|
|
{
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
switch (simulator.getSimulator())
|
|
{
|
|
case CSimulatorInfo::FS9: return this->m_simSettingsFs9.get();
|
|
case CSimulatorInfo::FSX: return this->m_simSettingsFsx.get();
|
|
case CSimulatorInfo::P3D: return this->m_simSettingsP3D.get();
|
|
case CSimulatorInfo::XPLANE: return this->m_simSettingsXP.get();
|
|
default:
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
break;
|
|
}
|
|
return CSettingsSimulator();
|
|
}
|
|
|
|
CStatusMessage CMultiSimulatorSimulatorSettings::setSettings(const CSettingsSimulator &settings, const CSimulatorInfo &simulator)
|
|
{
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
switch (simulator.getSimulator())
|
|
{
|
|
case CSimulatorInfo::FS9: return this->m_simSettingsFs9.set(settings);
|
|
case CSimulatorInfo::FSX: return this->m_simSettingsFsx.set(settings);
|
|
case CSimulatorInfo::P3D: return this->m_simSettingsP3D.set(settings);
|
|
case CSimulatorInfo::XPLANE: return this->m_simSettingsXP.set(settings);
|
|
default:
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
break;
|
|
}
|
|
return CStatusMessage({ CLogCategory::settings() }, CStatusMessage::SeverityError, "wrong simulator");
|
|
}
|
|
|
|
CStatusMessage CMultiSimulatorSimulatorSettings::setAndSaveSettings(const CSettingsSimulator &settings, const CSimulatorInfo &simulator)
|
|
{
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
switch (simulator.getSimulator())
|
|
{
|
|
case CSimulatorInfo::FS9: return this->m_simSettingsFs9.setAndSave(settings);
|
|
case CSimulatorInfo::FSX: return this->m_simSettingsFsx.setAndSave(settings);
|
|
case CSimulatorInfo::P3D: return this->m_simSettingsP3D.setAndSave(settings);
|
|
case CSimulatorInfo::XPLANE: return this->m_simSettingsXP.setAndSave(settings);
|
|
default:
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
break;
|
|
}
|
|
return CStatusMessage({ CLogCategory::settings() }, CStatusMessage::SeverityError, "wrong simulator");
|
|
}
|
|
|
|
CStatusMessage CMultiSimulatorSimulatorSettings::saveSettings(const CSimulatorInfo &simulator)
|
|
{
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
switch (simulator.getSimulator())
|
|
{
|
|
case CSimulatorInfo::FS9: return this->m_simSettingsFs9.save();
|
|
case CSimulatorInfo::FSX: return this->m_simSettingsFsx.save();
|
|
case CSimulatorInfo::P3D: return this->m_simSettingsP3D.save();
|
|
case CSimulatorInfo::XPLANE: return this->m_simSettingsXP.save();
|
|
default:
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
break;
|
|
}
|
|
return CStatusMessage({ CLogCategory::settings() }, CStatusMessage::SeverityError, "wrong simulator");
|
|
}
|
|
|
|
QString CMultiSimulatorSimulatorSettings::getSimulatorDirectoryOrDefault(const CSimulatorInfo &simulator) const
|
|
{
|
|
const CSettingsSimulator s = this->getSettings(simulator);
|
|
if (s.getSimulatorDirectory().isEmpty())
|
|
{
|
|
return this->getDefaultSimulatorDirectory(simulator);
|
|
}
|
|
return s.getSimulatorDirectory();
|
|
}
|
|
|
|
QString CMultiSimulatorSimulatorSettings::getDefaultSimulatorDirectory(const CSimulatorInfo &simulator) const
|
|
{
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
switch (simulator.getSimulator())
|
|
{
|
|
case CSimulatorInfo::FS9: return CFsCommonUtil::fs9Dir();
|
|
case CSimulatorInfo::FSX: return CFsCommonUtil::fsxDir();
|
|
case CSimulatorInfo::P3D: return CFsCommonUtil::p3dDir();
|
|
case CSimulatorInfo::XPLANE: return CXPlaneUtil::xplaneRootDir(); //! check XP
|
|
default:
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
break;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
QStringList CMultiSimulatorSimulatorSettings::getModelDirectoriesOrDefault(const CSimulatorInfo &simulator) const
|
|
{
|
|
const CSettingsSimulator s = this->getSettings(simulator);
|
|
if (s.getModelDirectories().isEmpty())
|
|
{
|
|
return this->getDefaultModelDirectories(simulator);
|
|
}
|
|
return s.getModelDirectories();
|
|
}
|
|
|
|
QString CMultiSimulatorSimulatorSettings::getFirstModelDirectoryOrDefault(const CSimulatorInfo &simulator) const
|
|
{
|
|
const QStringList models(getModelDirectoriesOrDefault(simulator));
|
|
if (models.isEmpty()) { return ""; }
|
|
return models.first();
|
|
}
|
|
|
|
QStringList CMultiSimulatorSimulatorSettings::getDefaultModelDirectories(const CSimulatorInfo &simulator) const
|
|
{
|
|
static const QStringList e;
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
switch (simulator.getSimulator())
|
|
{
|
|
case CSimulatorInfo::FS9: return CFsCommonUtil::fs9AircraftDir().isEmpty() ? e : QStringList({ CFsCommonUtil::fs9AircraftDir() });
|
|
case CSimulatorInfo::FSX: return CFsCommonUtil::fsxSimObjectsDir().isEmpty() ? e : QStringList({ CFsCommonUtil::fsxSimObjectsDir() });
|
|
case CSimulatorInfo::P3D: return CFsCommonUtil::p3dSimObjectsDir().isEmpty() ? e : QStringList({ CFsCommonUtil::p3dSimObjectsDir()});
|
|
case CSimulatorInfo::XPLANE: return CXPlaneUtil::xplaneModelDirectories();
|
|
default:
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
break;
|
|
}
|
|
return QStringList();
|
|
}
|
|
|
|
QStringList CMultiSimulatorSimulatorSettings::getModelExcludeDirectoryPatternsOrDefault(const CSimulatorInfo &simulator) const
|
|
{
|
|
const CSettingsSimulator s = this->getSettings(simulator);
|
|
QStringList exclude(s.getModelExcludeDirectoryPatterns());
|
|
if (!exclude.isEmpty()) { return exclude; }
|
|
exclude = this->getDefaultModelExcludeDirectoryPatterns(simulator);
|
|
return exclude;
|
|
}
|
|
|
|
QStringList CMultiSimulatorSimulatorSettings::getDefaultModelExcludeDirectoryPatterns(const CSimulatorInfo &simulator) const
|
|
{
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
switch (simulator.getSimulator())
|
|
{
|
|
case CSimulatorInfo::FS9: return CFsCommonUtil::fs9AircraftObjectsExcludeDirectoryPatterns();
|
|
case CSimulatorInfo::FSX: return CFsCommonUtil::fsxSimObjectsExcludeDirectoryPatterns();
|
|
case CSimulatorInfo::P3D: return CFsCommonUtil::p3dSimObjectsExcludeDirectoryPatterns();
|
|
case CSimulatorInfo::XPLANE: return CXPlaneUtil::xplaneModelExcludeDirectoryPatterns();
|
|
default:
|
|
Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
|
|
break;
|
|
}
|
|
return QStringList();
|
|
}
|
|
|
|
void CMultiSimulatorSimulatorSettings::resetToDefaults(const CSimulatorInfo &simulator)
|
|
{
|
|
CSettingsSimulator s = this->getSettings(simulator);
|
|
s.resetPaths();
|
|
this->setAndSaveSettings(s, simulator);
|
|
}
|
|
|
|
CSettingsSimulatorMessages::CSettingsSimulatorMessages()
|
|
{
|
|
// void
|
|
}
|
|
|
|
void CSettingsSimulatorMessages::setTechnicalLogSeverity(CStatusMessage::StatusSeverity severity)
|
|
{
|
|
this->m_technicalLogLevel = static_cast<int>(severity);
|
|
}
|
|
|
|
void CSettingsSimulatorMessages::disableTechnicalMessages()
|
|
{
|
|
this->m_technicalLogLevel = -1;
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedErrorsMessages() const
|
|
{
|
|
if (this->m_technicalLogLevel < 0) { return false; }
|
|
return (this->m_technicalLogLevel <= CStatusMessage::SeverityError);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedWarningMessages() const
|
|
{
|
|
if (this->m_technicalLogLevel < 0) { return false; }
|
|
return (this->m_technicalLogLevel <= CStatusMessage::SeverityWarning);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedInfoMessages() const
|
|
{
|
|
if (this->m_technicalLogLevel < 0) { return false; }
|
|
return (this->m_technicalLogLevel <= CStatusMessage::SeverityInfo);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedTechnicalMessages() const
|
|
{
|
|
return (this->m_technicalLogLevel >= 0);
|
|
}
|
|
|
|
void CSettingsSimulatorMessages::setRelayedTextMessages(CSettingsSimulatorMessages::TextMessageType messageType)
|
|
{
|
|
this->m_messageType = static_cast<int>(messageType);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedSupervisorTextMessages() const
|
|
{
|
|
return this->getRelayedTextMessageTypes().testFlag(TextMessageSupervisor);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedPrivateTextMessages() const
|
|
{
|
|
return this->getRelayedTextMessageTypes().testFlag(TextMessagePrivate);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedUnicomTextMessages() const
|
|
{
|
|
return this->getRelayedTextMessageTypes().testFlag(TextMessagesUnicom);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedCom1TextMessages() const
|
|
{
|
|
return this->getRelayedTextMessageTypes().testFlag(TextMessagesCom1);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedCom2TextMessages() const
|
|
{
|
|
return this->getRelayedTextMessageTypes().testFlag(TextMessagesCom2);
|
|
}
|
|
|
|
bool CSettingsSimulatorMessages::isRelayedTextMessage(const Network::CTextMessage &msg, const BlackMisc::Simulation::CSimulatedAircraft &aircraft) const
|
|
{
|
|
if (msg.isEmpty()) { return false; }
|
|
if (!this->isGloballyEnabled()) { return false; }
|
|
if (this->m_messageType == NoTextMessages) { return false; }
|
|
|
|
const TextMessageType mt = static_cast<TextMessageType>(this->m_messageType);
|
|
if (msg.isPrivateMessage() && mt.testFlag(TextMessagePrivate)) { return true; }
|
|
if (msg.isSupervisorMessage() && (mt.testFlag(TextMessagePrivate) || mt.testFlag(TextMessageSupervisor))) { return true; }
|
|
if (msg.isSendToUnicom() && mt.testFlag(TextMessagesUnicom)) { return true; }
|
|
|
|
if (msg.isRadioMessage())
|
|
{
|
|
const CFrequency f(msg.getFrequency());
|
|
if (mt.testFlag(TextMessagesCom1))
|
|
{
|
|
if (aircraft.getCom1System().isActiveFrequencyWithin8_33kHzChannel(f)) { return true; }
|
|
}
|
|
if (mt.testFlag(TextMessagesCom2))
|
|
{
|
|
if (aircraft.getCom2System().isActiveFrequencyWithin8_33kHzChannel(f)) { return true; }
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
CSettingsSimulatorMessages::TextMessageType CSettingsSimulatorMessages::getRelayedTextMessageTypes() const
|
|
{
|
|
return static_cast<CSettingsSimulatorMessages::TextMessageType>(this->m_messageType);
|
|
}
|
|
|
|
QString CSettingsSimulatorMessages::convertToQString(bool i18n) const
|
|
{
|
|
Q_UNUSED(i18n);
|
|
QString s("Enabled %1, text messages: %2, severity: %3");
|
|
QString severity;
|
|
if (this->isRelayedTechnicalMessages())
|
|
{
|
|
severity = "No tech. msgs";
|
|
}
|
|
else
|
|
{
|
|
severity = CStatusMessage::severityToString(static_cast<CStatusMessage::StatusSeverity>(this->m_technicalLogLevel));
|
|
}
|
|
return s.arg(boolToOnOff(this->m_globallyEnabled)).arg(this->m_messageType).arg(severity);
|
|
}
|
|
|
|
CVariant CSettingsSimulatorMessages::propertyByIndex(const CPropertyIndex &index) const
|
|
{
|
|
if (index.isMyself()) { return CVariant::from(*this); }
|
|
ColumnIndex i = index.frontCasted<ColumnIndex>();
|
|
switch (i)
|
|
{
|
|
case IndexTechnicalLogSeverity:
|
|
return CVariant::fromValue(this->m_technicalLogLevel);
|
|
case IndexTextMessageRelay:
|
|
return CVariant::from(this->m_messageType);
|
|
case IndexGloballyEnabled:
|
|
return CVariant::from(this->m_globallyEnabled);
|
|
default:
|
|
return CValueObject::propertyByIndex(index);
|
|
}
|
|
}
|
|
|
|
void CSettingsSimulatorMessages::setPropertyByIndex(const CPropertyIndex &index, const CVariant &variant)
|
|
{
|
|
if (index.isMyself()) { (*this) = variant.to<CSettingsSimulatorMessages>(); return; }
|
|
ColumnIndex i = index.frontCasted<ColumnIndex>();
|
|
switch (i)
|
|
{
|
|
case IndexTechnicalLogSeverity:
|
|
this->setTechnicalLogSeverity(static_cast<CStatusMessage::StatusSeverity>(variant.toInt()));
|
|
break;
|
|
case IndexTextMessageRelay:
|
|
this->setRelayedTextMessages(static_cast<CSettingsSimulatorMessages::TextMessageType>(variant.toInt()));
|
|
break;
|
|
case IndexGloballyEnabled:
|
|
this->setGloballyEnabled(variant.toBool());
|
|
break;
|
|
default:
|
|
CValueObject::setPropertyByIndex(index, variant);
|
|
break;
|
|
}
|
|
}
|
|
} // ns
|
|
} // ns
|
|
} // ns
|