simulatorsettings.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_SIMULATION_SETTINGS_SIMULATORSETTINGS_H
#define SWIFT_MISC_SIMULATION_SETTINGS_SIMULATORSETTINGS_H
 
#include <QObject>
#include <QStringList>
 
#include "misc/directoryutils.h"
#include "misc/network/textmessage.h"
#include "misc/pq/length.h"
#include "misc/propertyindexref.h"
#include "misc/settingscache.h"
#include "misc/simulation/simulatedaircraft.h"
#include "misc/simulation/simulatorinfo.h"
#include "misc/statusmessage.h"
#include "misc/swiftmiscexport.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::simulation::Settings, CSimulatorSettings)
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::simulation::Settings, CFsxP3DSettings)
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::simulation::Settings, CSimulatorMessagesSettings)
 
namespace swift::misc::simulation::settings
{
    class SWIFT_MISC_EXPORT CSimulatorSettings : public CValueObject<CSimulatorSettings>
    {
    public:
        enum ColumnIndex
        {
            IndexSimulatorDirectory = CPropertyIndexRef::GlobalIndexCSimulatorSettings,
            IndexModelDirectories,
            IndexModelExcludeDirectoryPatterns,
            IndexComIntegration, 
            IndexCGSource,
            IndexRecordOwnAircraftGnd,
            IndexRecordOwnAircraftGndRadius
        };
 
        enum CGSource
        {
            CGFromSimulatorFirst,
            CGFromDBFirst,
            CGFromSimulatorOnly,
            CGFromDBOnly
        };
 
        static const QString &cgSourceAsString(CGSource source);
 
        CSimulatorSettings() = default;
 
        CSimulatorSettings(const QString &simDir) : m_simulatorDirectory(simDir) {}
 
        void setSimulatorDirectory(const QString &simulatorDirectory);
 
        const QString &getSimulatorDirectory() const;
 
        bool hasSimulatorDirectory() const { return !this->getSimulatorDirectory().isEmpty(); }
 
        void setModelDirectories(const QStringList &modelDirectories);
 
        void clearModelDirectories();
 
        void setModelDirectory(const QString &modelDirectory);
 
        bool addModelDirectory(const QString &modelDirectory);
 
        const QStringList &getModelDirectories() const;
 
        bool hasModelDirectories() const { return !this->getModelDirectories().isEmpty(); }
 
        void setModelExcludeDirectories(const QStringList &excludeDirectories);
 
        const QStringList &getModelExcludeDirectoryPatterns() const;
 
        bool hasModelExcludeDirectoryPatterns() const { return !this->getModelExcludeDirectoryPatterns().isEmpty(); }
 
        bool isComIntegrated() const { return m_comIntegration; }
 
        bool setComIntegrated(bool integrated);
 
        CGSource getCGSource() const { return static_cast<CGSource>(m_cgSource); }
 
        bool setCGSource(CGSource source);
 
        bool isRecordOwnAircraftGnd() const { return m_recordGnd; }
 
        bool setRecordOwnAircraftGnd(bool record);
 
        swift::misc::physical_quantities::CLength getRecordedGndRadius() const { return m_recordedGndRadius; }
 
        bool setRecordedGndRadius(const swift::misc::physical_quantities::CLength &radius);
 
        void resetPaths();
 
        QString convertToQString(bool i18n = false) const;
 
        QString convertToQString(const QString &separator, bool i18n = false) const;
 
        QVariant propertyByIndex(CPropertyIndexRef index) const;
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
    private:
        QString m_simulatorDirectory; 
        QStringList m_modelDirectories; 
        QStringList m_excludeDirectoryPatterns; 
        bool m_comIntegration = false; 
        bool m_recordGnd = false; 
        int m_cgSource = static_cast<int>(CGFromSimulatorFirst); 
        physical_quantities::CLength m_recordedGndRadius { 250.0, physical_quantities::CLengthUnit::m() };
 
        SWIFT_METACLASS(
            CSimulatorSettings,
            SWIFT_METAMEMBER(simulatorDirectory),
            SWIFT_METAMEMBER(modelDirectories),
            SWIFT_METAMEMBER(excludeDirectoryPatterns),
            SWIFT_METAMEMBER(comIntegration),
            SWIFT_METAMEMBER(cgSource),
            SWIFT_METAMEMBER(recordGnd),
            SWIFT_METAMEMBER(recordedGndRadius));
    };
 
    class SWIFT_MISC_EXPORT CFsxP3DSettings : public CValueObject<CFsxP3DSettings>
    {
    public:
        CFsxP3DSettings() = default;
 
        CFsxP3DSettings(bool simulatedObject, bool sbOffsets)
            : m_useSimulatedObjectAdding(simulatedObject), m_useSbOffsets(sbOffsets)
        {}
 
        void setAddingAsSimulatedObjectEnabled(bool enable) { m_useSimulatedObjectAdding = enable; }
 
        bool isAddingAsSimulatedObjectEnabled() const { return m_useSimulatedObjectAdding; }
 
        void setSbOffsetsEnabled(bool enable) { m_useSbOffsets = enable; }
 
        bool isSbOffsetsEnabled() const { return m_useSbOffsets; }
 
        QString convertToQString(bool i18n = false) const;
 
        QVariant propertyByIndex(CPropertyIndexRef index) const;
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
    private:
        bool m_useSimulatedObjectAdding = false; 
        bool m_useSbOffsets = true; 
 
        SWIFT_METACLASS(
            CFsxP3DSettings,
            SWIFT_METAMEMBER(useSimulatedObjectAdding),
            SWIFT_METAMEMBER(useSbOffsets));
    };
 
    class SWIFT_MISC_EXPORT CSpecializedSimulatorSettings
    {
    public:
        const CSimulatorSettings &getGenericSettings() const { return m_genericSettings; }
 
        CSpecializedSimulatorSettings(const CSimulatorSettings &settings, const CSimulatorInfo &simulator)
            : m_genericSettings(settings), m_simulator(simulator)
        {}
 
        CSpecializedSimulatorSettings(const QString &simulatorDir, const CSimulatorInfo &simulator)
            : m_genericSettings(CSimulatorSettings(simulatorDir)), m_simulator(simulator)
        {}
 
        const CSimulatorSettings &getSimulatorSettings() const { return m_genericSettings; }
 
        const QString &getDefaultSimulatorDirectory() const;
 
        const QString &getSimulatorDirectoryIfNotDefault() const;
 
        const QString &getSimulatorDirectoryOrDefault() const;
 
        QStringList getModelDirectoriesOrDefault() const;
 
        QStringList getModelDirectoriesFromSimulatorDirectoy() const;
 
        QStringList getModelDirectoriesFromSimulatorDirectoryOrDefault() const;
 
        const QStringList &getModelDirectoriesIfNotDefault() const;
 
        const QStringList &getDefaultModelExcludeDirectoryPatterns() const;
 
        QString getFirstModelDirectoryOrDefault() const;
 
        const QStringList &getDefaultModelDirectories() const;
 
        const QStringList &getModelExcludeDirectoryPatternsIfNotDefault() const;
 
        const QStringList &getModelExcludeDirectoryPatternsOrDefault() const;
 
        void clearModelDirectories() { m_genericSettings.clearModelDirectories(); }
 
        bool addModelDirectory(const QString &modelDirectory)
        {
            return m_genericSettings.addModelDirectory(modelDirectory);
        }
 
        void setSimulatorDirectory(const QString &simDir) { m_genericSettings.setSimulatorDirectory(simDir); }
 
        static const QStringList &defaultModelDirectories(const CSimulatorInfo &simulator);
 
        static const QString &defaultSimulatorDirectory(const CSimulatorInfo &simulator);
 
        static const QStringList &defaultModelExcludeDirectoryPatterns(const CSimulatorInfo &simulator);
 
    protected:
        CSimulatorSettings m_genericSettings; 
        CSimulatorInfo m_simulator; 
    };
 
    class SWIFT_MISC_EXPORT CXPlaneSimulatorSettings : public CSpecializedSimulatorSettings
    {
    public:
        CXPlaneSimulatorSettings(const CSimulatorSettings &settings)
            : CSpecializedSimulatorSettings(settings, CSimulatorInfo(CSimulatorInfo::XPLANE))
        {}
 
        CXPlaneSimulatorSettings(const CSpecializedSimulatorSettings &settings)
            : CXPlaneSimulatorSettings(settings.getGenericSettings())
        {}
 
        QString getPluginDirOrDefault() const;
    };
 
    struct TSimulatorP3D : public TSettingTrait<CSimulatorSettings>
    {
        static const char *key() { return "settingssimulatorp3d"; }
 
        static const QString &humanReadable()
        {
            static const QString name("P3D settings");
            return name;
        }
    };
 
    struct TSimulatorMsfs : public TSettingTrait<CSimulatorSettings>
    {
        static const char *key() { return "settingssimulatormsfs"; }
 
        static const QString &humanReadable()
        {
            static const QString name("MSFS settings");
            return name;
        }
    };
 
    struct TSimulatorMsfs2024 : public TSettingTrait<CSimulatorSettings>
    {
        static const char *key() { return "settingssimulatormsfs2024"; }
 
        static const QString &humanReadable()
        {
            static const QString name("MSFS2024 settings");
            return name;
        }
    };
 
    struct TP3DVersion : public TSettingTrait<QString>
    {
        static const char *key() { return "simulator/p3dversion"; }
 
        static const QString &humanReadable()
        {
            static const QString name("P3D version");
            return name;
        }
 
        static const QString &defaultValue()
        {
            static const QString version("4.3");
            return version;
        }
    };
 
    struct TFsxDetailsSettings : public TSettingTrait<CFsxP3DSettings>
    {
        static const char *key() { return "simulator/fsxdetailsettings"; }
 
        static const QString &humanReadable()
        {
            static const QString name("FSX details");
            return name;
        }
 
        static const CFsxP3DSettings &defaultValue()
        {
            static const CFsxP3DSettings d(true, true);
            return d;
        }
    };
 
    struct TP3DDetailsSettings : public TSettingTrait<CFsxP3DSettings>
    {
        static const char *key() { return "simulator/p3ddetailsettings"; }
 
        static const QString &humanReadable()
        {
            static const QString name("P3D details");
            return name;
        }
 
        static const CFsxP3DSettings &defaultValue()
        {
            static const CFsxP3DSettings d(false, true);
            return d;
        }
    };
 
    struct SWIFT_MISC_EXPORT TSimulatorXP : public TSettingTrait<CSimulatorSettings>
    {
        static const char *key() { return "settingssimulatorxplane"; }
 
        static const QString &humanReadable()
        {
            static const QString name("XPlane settings");
            return name;
        }
 
        static bool isValid(const CSimulatorSettings &value, QString &reason);
    };
 
    struct TSimulatorFG : public TSettingTrait<CSimulatorSettings>
    {
        static const char *key() { return "settingssimulatorfg"; }
 
        static const QString &humanReadable()
        {
            static const QString name("FG settings");
            return name;
        }
    };
 
    class SWIFT_MISC_EXPORT CMultiSimulatorDetailsSettings : public QObject
    {
    public:
        CFsxP3DSettings getSettings(const CSimulatorInfo &sim) const;
 
        CStatusMessage setSettings(const CFsxP3DSettings &settings, const CSimulatorInfo &simulator);
 
        CStatusMessage setAndSaveSettings(const CFsxP3DSettings &settings, const CSimulatorInfo &simulator);
 
    private:
        CSetting<TFsxDetailsSettings> m_simFsx { this }; 
        CSetting<TP3DDetailsSettings> m_simP3D { this }; 
    };
 
    class SWIFT_MISC_EXPORT CMultiSimulatorSettings : public QObject
    {
        Q_OBJECT
 
    public:
        CMultiSimulatorSettings(QObject *parent = nullptr);
 
        CSimulatorSettings getSettings(const CSimulatorInfo &simulator) const;
 
        CSpecializedSimulatorSettings getSpecializedSettings(const CSimulatorInfo &simulator) const;
 
        CStatusMessage setSettings(const CSimulatorSettings &settings, const CSimulatorInfo &simulator);
 
        CStatusMessage addModelDirectory(const QString &modelDirectory, const CSimulatorInfo &simulator);
 
        CStatusMessage clearModelDirectories(const CSimulatorInfo &simulator);
 
        CStatusMessageList setAndValidateSettings(const CSimulatorSettings &settings, const CSimulatorInfo &simulator);
 
        CStatusMessage setAndSaveSettings(const CSimulatorSettings &settings, const CSimulatorInfo &simulator);
 
        CStatusMessage setAndSaveSettings(const CSpecializedSimulatorSettings &settings,
                                          const CSimulatorInfo &simulator);
 
        CStatusMessage saveSettings(const CSimulatorInfo &simulator);
 
        QString getSimulatorDirectoryIfNotDefault(const CSimulatorInfo &simulator) const;
 
        QString getSimulatorDirectoryOrDefault(const CSimulatorInfo &simulator) const;
 
        QStringList getModelDirectoriesIfNotDefault(const CSimulatorInfo &simulator) const;
 
        QStringList getModelDirectoriesOrDefault(const CSimulatorInfo &simulator) const;
 
        QString getFirstModelDirectoryOrDefault(const CSimulatorInfo &simulator) const;
 
        QStringList getModelExcludeDirectoryPatternsIfNotDefault(const CSimulatorInfo &simulator) const;
 
        QStringList getModelExcludeDirectoryPatternsOrDefault(const CSimulatorInfo &simulator) const;
 
        void resetToDefaults(const CSimulatorInfo &simulator);
 
        const QStringList &defaultModelDirectories(const CSimulatorInfo &simulator) const;
 
    signals:
        void settingsChanged(const swift::misc::simulation::CSimulatorInfo &simulator);
 
    private:
        CSetting<TSimulatorP3D> m_simSettingsP3D { this,
                                                   &CMultiSimulatorSettings::onP3DSettingsChanged }; 
        CSetting<TSimulatorMsfs> m_simSettingsMsfs {
            this, &CMultiSimulatorSettings::onMsfsSettingsChanged
        }; 
        CSetting<TSimulatorMsfs2024> m_simSettingsMsfs2024 {
            this, &CMultiSimulatorSettings::onMsfs2024SettingsChanged
        }; 
        CSetting<TSimulatorXP> m_simSettingsXP { this, &CMultiSimulatorSettings::onXPSettingsChanged }; 
        CSetting<TSimulatorFG> m_simSettingsFG { this, &CMultiSimulatorSettings::onFGSettingsChanged }; 
 
        void onP3DSettingsChanged();
        void onMsfsSettingsChanged();
        void onMsfs2024SettingsChanged();
        void onXPSettingsChanged();
        void onFGSettingsChanged();
 
        void emitSettingsChanged(const CSimulatorInfo &simInfo);
    };
 
    class SWIFT_MISC_EXPORT CSimulatorMessagesSettings : public CValueObject<CSimulatorMessagesSettings>
    {
    public:
        enum ColumnIndex
        {
            IndexTechnicalLogSeverity = CPropertyIndexRef::GlobalIndexCSimulatorMessageSettings,
            IndexRelayTextMessage,
            IndexRelayGloballyEnabled
        };
 
        enum TextMessageTypeFlag
        {
            NoTextMessages = 0,
            TextMessagesUnicom = 1 << 0,
            TextMessagesCom1 = 1 << 1,
            TextMessagesCom2 = 1 << 2,
            TextMessagePrivate = 1 << 3,
            TextMessageSupervisor = 1 << 4,
            TextMessagesAll = TextMessagesUnicom | TextMessagesCom1 | TextMessagesCom2 | TextMessagePrivate
        };
        Q_DECLARE_FLAGS(TextMessageType, TextMessageTypeFlag)
 
        
        CSimulatorMessagesSettings() = default;
 
        void setTechnicalLogSeverity(CStatusMessage::StatusSeverity severity);
 
        void setRelayGloballyEnabled(bool enabled) { m_relayGloballyEnabled = enabled; }
 
        bool isRelayGloballyEnabled() const { return m_relayGloballyEnabled; }
 
        void disableTechnicalMessages();
 
        bool isRelayErrorsMessages() const;
 
        bool isRelayWarningMessages() const;
 
        bool isRelayInfoMessages() const;
 
        bool isRelayTechnicalMessages() const;
 
        void setRelayTextMessages(CSimulatorMessagesSettings::TextMessageType messageType);
 
        bool isRelaySupervisorTextMessages() const;
 
        bool isRelayPrivateTextMessages() const;
 
        bool isRelayUnicomTextMessages() const;
 
        bool isRelayCom1TextMessages() const;
 
        bool isRelayCom2TextMessages() const;
 
        bool relayThisTextMessage(const network::CTextMessage &msg, const CSimulatedAircraft &aircraft) const;
 
        bool relayThisStatusMessage(const CStatusMessage &message) const;
 
        CSimulatorMessagesSettings::TextMessageType getRelayedTextMessageTypes() const;
 
        QString convertToQString(bool i18n = false) const;
 
        QVariant propertyByIndex(CPropertyIndexRef index) const;
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
    private:
        int m_technicalLogLevel = CStatusMessage::SeverityError; 
        int m_messageType = static_cast<int>(TextMessagePrivate | TextMessageSupervisor);
        bool m_relayGloballyEnabled = true; 
 
        SWIFT_METACLASS(
            CSimulatorMessagesSettings,
            SWIFT_METAMEMBER(technicalLogLevel),
            SWIFT_METAMEMBER(messageType));
    };
 
    struct TSimulatorMessages : public TSettingTrait<CSimulatorMessagesSettings>
    {
        static const char *key() { return "settingssimulatormessages"; }
 
        static const QString &humanReadable()
        {
            static const QString name("Simulator messages");
            return name;
        }
    };
 
} // namespace swift::misc::simulation::settings
 
Q_DECLARE_METATYPE(swift::misc::simulation::settings::CSimulatorSettings)
Q_DECLARE_METATYPE(swift::misc::simulation::settings::CSimulatorSettings::CGSource)
Q_DECLARE_METATYPE(swift::misc::simulation::settings::CFsxP3DSettings)
Q_DECLARE_METATYPE(swift::misc::CCollection<swift::misc::simulation::settings::CSimulatorSettings>)
Q_DECLARE_METATYPE(swift::misc::simulation::settings::CSimulatorMessagesSettings)
Q_DECLARE_METATYPE(swift::misc::CCollection<swift::misc::simulation::settings::CSimulatorMessagesSettings>)
Q_DECLARE_METATYPE(swift::misc::simulation::settings::CSimulatorMessagesSettings::TextMessageTypeFlag)
Q_DECLARE_METATYPE(swift::misc::simulation::settings::CSimulatorMessagesSettings::TextMessageType)
Q_DECLARE_OPERATORS_FOR_FLAGS(swift::misc::simulation::settings::CSimulatorMessagesSettings::TextMessageType)
 
#endif // SWIFT_MISC_SIMULATION_SETTINGS_SIMULATORSETTINGS_H