Ref T252, bundled directory handling for simulators in specialized settings

* class CSpecializedSimulatorSettings and CXPlaneSimulatorSettings
* allows to combine default directory functions directly with the settings values

src/blackmisc/simulation/settings/simulatorsettings.cpp

@@ -38,11 +38,6 @@ namespace BlackMisc
                 return m_simulatorDirectory;
             }
 
-            bool CSimulatorSettings::hasSimulatorDirectory() const
-            {
-                return !getSimulatorDirectory().isEmpty();
-            }
-
             void CSimulatorSettings::setModelDirectories(const QStringList &modelDirectories)
             {
                 m_modelDirectories = modelDirectories;
@@ -137,6 +132,11 @@ namespace BlackMisc
                 return CSimulatorSettings();
             }
 
+            CSpecializedSimulatorSettings CMultiSimulatorSettings::getSpecializedSettings(const CSimulatorInfo &simulator) const
+            {
+                return CSpecializedSimulatorSettings(this->getSettings(simulator), simulator);
+            }
+
             CStatusMessage CMultiSimulatorSettings::setSettings(const CSimulatorSettings &settings, const CSimulatorInfo &simulator)
             {
                 Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
@@ -187,104 +187,44 @@ namespace BlackMisc
 
             QString CMultiSimulatorSettings::getSimulatorDirectoryIfNotDefault(const CSimulatorInfo &simulator) const
             {
-                const CSimulatorSettings s = this->getSettings(simulator);
+                const CSpecializedSimulatorSettings s = this->getSpecializedSettings(simulator);
-                const QString dir = s.getSimulatorDirectory();
+                return s.getSimulatorDirectoryIfNotDefault();
-                if (dir.isEmpty() || dir == CMultiSimulatorSettings::getDefaultSimulatorDirectory(simulator))
-                {
-                    return QStringLiteral("");
-                }
-                return s.getSimulatorDirectory();
             }
 
             QString CMultiSimulatorSettings::getSimulatorDirectoryOrDefault(const CSimulatorInfo &simulator) const
             {
-                const CSimulatorSettings s = this->getSettings(simulator);
+                const CSpecializedSimulatorSettings s = this->getSpecializedSettings(simulator);
-                if (s.getSimulatorDirectory().isEmpty())
+                return s.getSimulatorDirectoryOrDefault();
-                {
-                    return CMultiSimulatorSettings::getDefaultSimulatorDirectory(simulator);
-                }
-                return s.getSimulatorDirectory();
             }
 
             QStringList CMultiSimulatorSettings::getModelDirectoriesIfNotDefault(const CSimulatorInfo &simulator) const
             {
-                const CSimulatorSettings s = this->getSettings(simulator);
+                const CSpecializedSimulatorSettings s = this->getSpecializedSettings(simulator);
-                const QStringList dirs = s.getModelDirectories();
+                return s.getModelDirectoriesIfNotDefault();
-                if (dirs.isEmpty() || dirs == CMultiSimulatorSettings::getDefaultModelDirectories(simulator))
-                {
-                    return QStringList();
-                }
-                return dirs;
             }
 
             QStringList CMultiSimulatorSettings::getModelDirectoriesOrDefault(const CSimulatorInfo &simulator) const
             {
-                const CSimulatorSettings s = this->getSettings(simulator);
+                const CSpecializedSimulatorSettings s = this->getSpecializedSettings(simulator);
-                if (s.getModelDirectories().isEmpty())
+                return s.getModelDirectoriesOrDefault();
-                {
-                    return this->getDefaultModelDirectories(simulator);
-                }
-                return s.getModelDirectories();
             }
 
             QString CMultiSimulatorSettings::getFirstModelDirectoryOrDefault(const CSimulatorInfo &simulator) const
             {
-                const QStringList models(getModelDirectoriesOrDefault(simulator));
+                const CSpecializedSimulatorSettings s = this->getSpecializedSettings(simulator);
-                if (models.isEmpty()) { return ""; }
+                return s.getFirstModelDirectoryOrDefault();
-                return models.first();
-            }
-
-            QStringList CMultiSimulatorSettings::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 CMultiSimulatorSettings::getModelExcludeDirectoryPatternsIfNotDefault(const CSimulatorInfo &simulator) const
             {
-                const CSimulatorSettings s = this->getSettings(simulator);
+                const CSpecializedSimulatorSettings s = this->getSpecializedSettings(simulator);
-                const QStringList patterns = s.getModelExcludeDirectoryPatterns();
+                return s.getModelExcludeDirectoryPatternsIfNotDefault();
-                if (patterns.isEmpty() || patterns == CMultiSimulatorSettings::getDefaultModelExcludeDirectoryPatterns(simulator))
-                {
-                    return QStringList();
-                }
-                return patterns;
             }
 
             QStringList CMultiSimulatorSettings::getModelExcludeDirectoryPatternsOrDefault(const CSimulatorInfo &simulator) const
             {
-                const CSimulatorSettings s = this->getSettings(simulator);
+                const CSpecializedSimulatorSettings s = this->getSpecializedSettings(simulator);
-                QStringList exclude(s.getModelExcludeDirectoryPatterns());
+                return s.getModelExcludeDirectoryPatternsOrDefault();
-                if (!exclude.isEmpty()) { return exclude; }
-                exclude = this->getDefaultModelExcludeDirectoryPatterns(simulator);
-                return exclude;
-            }
-
-            QStringList CMultiSimulatorSettings::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 CMultiSimulatorSettings::resetToDefaults(const CSimulatorInfo &simulator)
@@ -294,26 +234,19 @@ namespace BlackMisc
                 this->setAndSaveSettings(s, simulator);
             }
 
-            QString CMultiSimulatorSettings::getDefaultSimulatorDirectory(const CSimulatorInfo &simulator)
+            const QStringList &CMultiSimulatorSettings::defaultModelDirectories(const CSimulatorInfo &simulator) const
             {
-                Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
+                return CSpecializedSimulatorSettings::defaultModelDirectories(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();
-                default:
-                    Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
-                    break;
-                }
-                static const QString empty;
-                return empty;
             }
 
-            CSimulatorMessagesSettings::CSimulatorMessagesSettings()
+            const QStringList &CMultiSimulatorSettings::defaultModelExcludeDirectoryPatterns(const CSimulatorInfo &simulator)
             {
-                // void
+                return CSpecializedSimulatorSettings::defaultModelExcludeDirectoryPatterns(simulator);
+            }
+
+            const QString &CMultiSimulatorSettings::defaultSimulatorDirectory(const CSimulatorInfo &simulator)
+            {
+                return CSpecializedSimulatorSettings::defaultSimulatorDirectory(simulator);
             }
 
             void CSimulatorMessagesSettings::setTechnicalLogSeverity(CStatusMessage::StatusSeverity severity)
@@ -460,6 +393,182 @@ namespace BlackMisc
                 default: CValueObject::setPropertyByIndex(index, variant); break;
                 }
             }
+
+            void CSpecializedSimulatorSettings::setSimulatorDirectory(const QString &simDir)
+            {
+                m_genericSettings.setSimulatorDirectory(simDir);
+            }
+
+            const QString &CSpecializedSimulatorSettings::getDefaultSimulatorDirectory() const
+            {
+                return CSpecializedSimulatorSettings::defaultSimulatorDirectory(m_simulator);
+            }
+
+            const QString &CSpecializedSimulatorSettings::getSimulatorDirectoryIfNotDefault() const
+            {
+                static const QString empty;
+                if (!m_genericSettings.hasSimulatorDirectory()) { return empty; }
+                if (m_genericSettings.getSimulatorDirectory() == CSpecializedSimulatorSettings::defaultSimulatorDirectory(m_simulator))
+                {
+                    return empty;
+                }
+                return m_genericSettings.getSimulatorDirectory();
+            }
+
+            const QString &CSpecializedSimulatorSettings::getSimulatorDirectoryOrDefault() const
+            {
+                return (m_genericSettings.hasSimulatorDirectory()) ?
+                       m_genericSettings.getSimulatorDirectory() :
+                       CSpecializedSimulatorSettings::defaultSimulatorDirectory(m_simulator);
+            }
+
+            const QStringList CSpecializedSimulatorSettings::getModelDirectoriesOrDefault() const
+            {
+                return m_genericSettings.hasModelDirectories() ?
+                       m_genericSettings.getModelDirectories() :
+                       this->getModelDirectoriesFromSimulatorDirectoryOrDefault();
+            }
+
+            const QStringList CSpecializedSimulatorSettings::getModelDirectoriesFromSimulatorDirectoy() const
+            {
+                if (!m_genericSettings.hasSimulatorDirectory()) { return QStringList(); }
+                const QString s(m_genericSettings.getSimulatorDirectory());
+                switch (m_simulator.getSimulator())
+                {
+                case CSimulatorInfo::FS9: return QStringList({CFsCommonUtil::fs9AircraftDirFromSimDir(s)});
+                case CSimulatorInfo::FSX: return QStringList({CFsCommonUtil::fsxSimObjectsDirFromSimDir(s)});
+                case CSimulatorInfo::P3D: return QStringList({CFsCommonUtil::p3dSimObjectsDirFromSimDir(s)});
+                case CSimulatorInfo::XPLANE: return QStringList({CXPlaneUtil::modelDirectoriesFromSimDir(s)});
+                default: break;
+                }
+                return QStringList();
+            }
+
+            const QStringList CSpecializedSimulatorSettings::getModelDirectoriesFromSimulatorDirectoryOrDefault() const
+            {
+                if (!m_genericSettings.hasSimulatorDirectory()) { return CSpecializedSimulatorSettings::defaultModelDirectories(m_simulator); }
+                return this->getModelDirectoriesFromSimulatorDirectoy();
+            }
+
+            const QStringList &CSpecializedSimulatorSettings::getModelDirectoriesIfNotDefault() const
+            {
+                static const QStringList empty;
+                if (!m_genericSettings.hasModelDirectories()) { return empty; }
+                if (m_genericSettings.getModelDirectories() == CSpecializedSimulatorSettings::defaultModelDirectories(m_simulator))
+                {
+                    return empty;
+                }
+                return m_genericSettings.getModelDirectories();
+            }
+
+            const QStringList &CSpecializedSimulatorSettings::getDefaultModelExcludeDirectoryPatterns() const
+            {
+                return CSpecializedSimulatorSettings::defaultModelExcludeDirectoryPatterns(m_simulator);
+            }
+
+            const QString CSpecializedSimulatorSettings::getFirstModelDirectoryOrDefault() const
+            {
+                static const QString empty;
+                if (this->getModelDirectoriesOrDefault().isEmpty()) { return empty; }
+                return this->getModelDirectoriesOrDefault().first();
+            }
+
+            const QStringList &CSpecializedSimulatorSettings::getDefaultModelDirectories() const
+            {
+                return CSpecializedSimulatorSettings::defaultModelDirectories(m_simulator);
+            }
+
+            const QStringList &CSpecializedSimulatorSettings::getModelExcludeDirectoryPatternsIfNotDefault() const
+            {
+                static const QStringList empty;
+                if (!m_genericSettings.hasModelExcludeDirectoryPatterns()) { return empty; }
+                if (m_genericSettings.getModelExcludeDirectoryPatterns() == CSpecializedSimulatorSettings::defaultModelExcludeDirectoryPatterns(m_simulator))
+                {
+                    return empty;
+                }
+                return m_genericSettings.getModelExcludeDirectoryPatterns();
+            }
+
+            const QStringList &CSpecializedSimulatorSettings::getModelExcludeDirectoryPatternsOrDefault() const
+            {
+                return m_genericSettings.hasModelExcludeDirectoryPatterns() ?
+                       m_genericSettings.getModelExcludeDirectoryPatterns() :
+                       CSpecializedSimulatorSettings::defaultModelExcludeDirectoryPatterns(m_simulator);
+            }
+
+            const QStringList &CSpecializedSimulatorSettings::defaultModelDirectories(const CSimulatorInfo &simulator)
+            {
+                Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
+                static const QStringList e;
+                switch (simulator.getSimulator())
+                {
+                case CSimulatorInfo::FS9:
+                    {
+                        if (CFsCommonUtil::fs9AircraftDir().isEmpty()) { return e; }
+                        static const QStringList md({ CFsCommonUtil::fs9AircraftDir() });
+                        return  md;
+                    }
+                case CSimulatorInfo::FSX:
+                    {
+                        if (CFsCommonUtil::fsxSimObjectsDir().isEmpty()) { return e; }
+                        static const QStringList md({ CFsCommonUtil::fsxSimObjectsDir() });
+                        return  md;
+                    }
+                case CSimulatorInfo::P3D:
+                    {
+                        if (CFsCommonUtil::p3dSimObjectsDir().isEmpty()) { return e; }
+                        static const QStringList md({ CFsCommonUtil::p3dSimObjectsDir() });
+                        return  md;
+                    }
+                case CSimulatorInfo::XPLANE:
+                    {
+                        return CXPlaneUtil::xplaneModelDirectories();
+                    }
+                default:
+                    Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
+                    break;
+                }
+                return e;
+            }
+
+            const QString &CSpecializedSimulatorSettings::defaultSimulatorDirectory(const CSimulatorInfo &simulator)
+            {
+                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();
+                default:
+                    Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
+                    break;
+                }
+                static const QString empty;
+                return empty;
+            }
+
+            const QStringList &CSpecializedSimulatorSettings::defaultModelExcludeDirectoryPatterns(const CSimulatorInfo &simulator)
+            {
+                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;
+                }
+                static const QStringList empty;
+                return empty;
+            }
+
+            const QString CXPlaneSimulatorSettings::getPluginDirOrDefault() const
+            {
+                return CFileUtils::appendFilePaths(this->getSimulatorDirectoryOrDefault(), CXPlaneUtil::xplanePluginPath());
+            }
         } // ns
     } // ns
 } // ns

src/blackmisc/simulation/settings/simulatorsettings.h

@@ -32,8 +32,7 @@ namespace BlackMisc
         {
             //! Settings for simulator
             //! Driver independent part also used in loaders (such as directories)
-            class BLACKMISC_EXPORT CSimulatorSettings :
+            class BLACKMISC_EXPORT CSimulatorSettings : public CValueObject<CSimulatorSettings>
-                public CValueObject<CSimulatorSettings>
             {
             public:
                 //! Properties by index
@@ -47,6 +46,9 @@ namespace BlackMisc
                 //! Default constructor
                 CSimulatorSettings();
 
+                //! Constructor
+                CSimulatorSettings(const QString &simDir) : m_simulatorDirectory(simDir) {}
+
                 //! Set simulator directory
                 void setSimulatorDirectory(const QString &simulatorDirectory);
 
@@ -54,7 +56,7 @@ namespace BlackMisc
                 const QString &getSimulatorDirectory() const;
 
                 //! Setting has simulator setting
-                bool hasSimulatorDirectory() const;
+                bool hasSimulatorDirectory() const { return !this->getSimulatorDirectory().isEmpty(); }
 
                 //! Set model directories
                 void setModelDirectories(const QStringList &modelDirectories);
@@ -65,12 +67,18 @@ namespace BlackMisc
                 //! Model directory
                 const QStringList &getModelDirectories() const;
 
+                //! Having model directories?
+                bool hasModelDirectories() const { return !this->getModelDirectories().isEmpty(); }
+
                 //! Set exclude directories
                 void setModelExcludeDirectories(const QStringList &excludeDirectories);
 
-                //! Margins for given dock widget
+                //! Model exclude directoy patterns
                 const QStringList &getModelExcludeDirectoryPatterns() const;
 
+                //! Having model exclude directoy patterns?
+                bool hasModelExcludeDirectoryPatterns() const { return !this->getModelExcludeDirectoryPatterns().isEmpty(); }
+
                 //! Reset the paths
                 void resetPaths();
 
@@ -99,6 +107,88 @@ namespace BlackMisc
                 );
             };
 
+            //! Allows to have specific utility functions for each simulator
+            class BLACKMISC_EXPORT CSpecializedSimulatorSettings
+            {
+            public:
+                //! Get the generic settings
+                const CSimulatorSettings &getGenericSettings() const { return m_genericSettings; }
+
+                //! Ctor
+                CSpecializedSimulatorSettings(const CSimulatorSettings &settings, const CSimulatorInfo &simulator) : m_genericSettings(settings), m_simulator(simulator) {}
+
+                //! Ctor
+                CSpecializedSimulatorSettings(const QString &simulatorDir, const CSimulatorInfo &simulator) : m_genericSettings(CSimulatorSettings(simulatorDir)), m_simulator(simulator) {}
+
+                //! Alter simulator directory
+                void setSimulatorDirectory(const QString &simDir);
+
+                //! Default simulator path per simulator
+                const QString &getDefaultSimulatorDirectory() const;
+
+                //! Simulator directory or empty if default dir
+                const QString &getSimulatorDirectoryIfNotDefault() const;
+
+                //! Simulator directory or default model path
+                const QString &getSimulatorDirectoryOrDefault() const;
+
+                //! Model directories or default
+                const QStringList getModelDirectoriesOrDefault() const;
+
+                //! Model directories
+                const QStringList getModelDirectoriesFromSimulatorDirectoy() const;
+
+                //! Model directories, then from simulator directory, then default
+                const QStringList getModelDirectoriesFromSimulatorDirectoryOrDefault() const;
+
+                //! Model directories or empty if default
+                const QStringList &getModelDirectoriesIfNotDefault() const;
+
+                //! Default model exclude patterns
+                const QStringList &getDefaultModelExcludeDirectoryPatterns() const;
+
+                //! First model directoy
+                const QString getFirstModelDirectoryOrDefault() const;
+
+                //! Model exclude patterns or empty if default
+                const QStringList &getDefaultModelDirectories() const;
+
+                //! Model exclude patterns or empty if default
+                const QStringList &getModelExcludeDirectoryPatternsIfNotDefault() const;
+
+                //! Model exclude patterns or empty if default
+                const QStringList &getModelExcludeDirectoryPatternsOrDefault() const;
+
+                //! Default model path per simulator
+                static const QStringList &defaultModelDirectories(const CSimulatorInfo &simulator);
+
+                //! Default simulator path per simulator
+                static const QString &defaultSimulatorDirectory(const CSimulatorInfo &simulator);
+
+                //! Default model exclude patterns per simulator
+                static const QStringList &defaultModelExcludeDirectoryPatterns(const CSimulatorInfo &simulator);
+
+            protected:
+                CSimulatorSettings m_genericSettings; //!< the generic settings
+                CSimulatorInfo m_simulator; //!< represented simulator
+            };
+
+            //! Allows to have specific utility functions for each simulator
+            class BLACKMISC_EXPORT CXPlaneSimulatorSettings : public CSpecializedSimulatorSettings
+            {
+            public:
+                //! Constructor
+                CXPlaneSimulatorSettings(const CSimulatorSettings &settings) : CSpecializedSimulatorSettings(settings, CSimulatorInfo(CSimulatorInfo::XPLANE))
+                {}
+
+                //! Constructor
+                CXPlaneSimulatorSettings(const CSpecializedSimulatorSettings &settings) : CXPlaneSimulatorSettings(settings.getGenericSettings())
+                {}
+
+                //! Plugin directory or default plugin dir
+                const QString getPluginDirOrDefault() const;
+            };
+
             //! Trait for simulator settings
             struct TSimulatorFsx : public TSettingTrait<CSimulatorSettings>
             {
@@ -151,6 +241,9 @@ namespace BlackMisc
                 //! Settings per simulator
                 CSimulatorSettings getSettings(const CSimulatorInfo &simulator) const;
 
+                //! Specialized simulator settings
+                CSpecializedSimulatorSettings getSpecializedSettings(const CSimulatorInfo &simulator) const;
+
                 //! Set settings per simulator
                 CStatusMessage setSettings(const CSimulatorSettings &settings, const CSimulatorInfo &simulator);
 
@@ -175,23 +268,25 @@ namespace BlackMisc
                 //! First model directoy
                 QString getFirstModelDirectoryOrDefault(const CSimulatorInfo &simulator) const;
 
-                //! Default model path per simulator
-                QStringList getDefaultModelDirectories(const CSimulatorInfo &simulator) const;
-
                 //! Model exclude patterns or empty if default
                 QStringList getModelExcludeDirectoryPatternsIfNotDefault(const CSimulatorInfo &simulator) const;
 
                 //! Model exclude patterns per simulator
                 QStringList getModelExcludeDirectoryPatternsOrDefault(const CSimulatorInfo &simulator) const;
 
-                //! Default model exclude patterns per simulator
-                QStringList getDefaultModelExcludeDirectoryPatterns(const CSimulatorInfo &simulator) const;
-
                 //! Reset to defaults
                 void resetToDefaults(const CSimulatorInfo &simulator);
 
+                //! Default model path per simulator
+                const QStringList &defaultModelDirectories(const CSimulatorInfo &simulator) const;
+
+                //! Default model exclude patterns per simulator
+                //! \deprecated use CSpecializedSimulatorSettings::defaultModelExcludeDirectoryPatterns
+                static const QStringList &defaultModelExcludeDirectoryPatterns(const CSimulatorInfo &simulator);
+
                 //! Default simulator path per simulator
-                static QString getDefaultSimulatorDirectory(const CSimulatorInfo &simulator);
+                //! \deprecated use CSpecializedSimulatorSettings::defaultSimulatorDirectory
+                static const QString &defaultSimulatorDirectory(const CSimulatorInfo &simulator);
 
             private:
                 CSetting<Settings::TSimulatorFsx> m_simSettingsFsx {this}; //!< FSX cache
@@ -227,7 +322,7 @@ namespace BlackMisc
                 Q_DECLARE_FLAGS(TextMessageType, TextMessageTypeFlag)
 
                 //! Default constructor
-                CSimulatorMessagesSettings();
+                CSimulatorMessagesSettings() {}
 
                 //! Log severity
                 void setTechnicalLogSeverity(CStatusMessage::StatusSeverity severity);