simulationModelSetLoader.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2020 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/


#pragma once

#if !defined(Q_MOC_RUN)
#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "simulationObjectEditorImpl/embarkationInformation.h"
#include "simulationObjectEditorImpl/diGuyInformation.h"
#include "simulationObjectEditorImpl/autoTagInformation.h"
#include "simulationObjectEditorImpl/sensorSignatureInformation.h"
#include "simulationObjectEditorImpl/simulationObjectEditorComponentSystemDatabase.h"
#include "vrfobjparam/damageAdjudicationComponentDescriptor.h"
#include <simulationObjectEditorImpl/orderedObjectTypeList.h>
#include <vrfutil/vrfCallbackQueue.h>

#include "vrfutil/simulationModelSet.h"
#include <vrfutil/rwForces.h>
#include <vrfutil/vrfSubObjectParameterList.h>
#include <vrfutil/vrfSubObjectParameterEntry.h>
#include <vrfutil/standardSensorObjects.h>
#include <vrfutil/scenarioExplorer.h>
#include <vrfutil/simulationObjectCategoryInformation.h>
#include <vrfutil/formationTable.h>
#include <vlutil/vlFilename.h>
#include <vrfutil/subordinateFunctionTable.h>
#include <mtl/envValue.h>
#include <matrix/3dBoundingVolume.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtUnicode.h>
#include <QtCore/QHash>
#include <QtGui/QPixmap>
#include <QtCore/QObject>
#include <vrfobjparam/modelSetEntry.h>
#include <vrvCore/DtElementDefinitionManager.h>
#include <smsChecksum/smsChecksum.h>

#include <vrfExtProtocol/objectType.h>
#include <tbb/mutex.h>
#include <tbb/spin_mutex.h>

#endif

class DtEnvList;
class DtRwVariableBindingsList;
class DtComponentSystemDescriptorList;
class DtVrfObjectParameters;
class DtComponentSystemDefinition;
class DtSystemParameterData;
class DtAmmunitionParamsEntry;
class DtSimulationObjectEditorScenarioExplorer;
class QTranslator;
class DtSimulationObjectGroupModelSetEntry;
class DtRwVisualMetaData;
class DtAmmunitionParams;
class DtDetonationParams;
class DtTerrainDeformationParams;
class DtMunitionDetonationPowerEntry;
class DtTargetingControlTable;
class DtDamageProbabilityTable;
class DtRangeProbabilityTable;
class DtAmmunitionManager;
class DtSimulationModelSetLoadProgressWidget;
class DtComponentSystemDescriptor;

namespace makVrf
{
   class DtEntityMapperKey;
   class DtVrfVisualsManager;
   class DtVrfEntityTypeMapper;
   class DtVrfGuiForceManager;
}

namespace makVrv
{
   class DtModelDefinitionManager;
   class DtEntityTypeMapper;
   class DtModelDefinition;
}

class DtObjectType;
class DtModelSet;
class QComboBox;
class DtSimulationModelSetLoader;
class DtVariableBindingList;
class DtSimArtPartDescriptorList;
class DtEnumLoader;
class DtEnumDictionary;

static const int DtTemplateKindBase = 400;

class DT_DLL_simulationObjectEditorimpl DtSimulationModelSetLoader : public makVrv::DtVirtualBaseClass
{
public:
   enum LoadFlags
   {
      LoadDataFiles = 0x00000001,
      LoadParameterFiles = 0x00000002,
      LoadSystemFiles = 0x00000004,
      LoadSupportingFiles = 0x00000008,
      LoadStandardSensorObjects = 0x00000010,
      LoadTranslationFiles = 0x00000020,
      LoadVisualFiles = 0x00000040,
      LoadOrCreateVisualFiles = 0x00000080,
      LoadAutoTagInformation = 0x00000100,
      LoadFunctionInformation = 0x00000200,
      LoadAll = LoadDataFiles | LoadParameterFiles | LoadSystemFiles | LoadSupportingFiles | LoadStandardSensorObjects | LoadTranslationFiles | LoadOrCreateVisualFiles | LoadAutoTagInformation | LoadFunctionInformation
   };

   enum CategoryTypes
   {
      SystemCategories = 0,
      EntityCategories = 1,
      DefaultDeployableCountries = 2,
      DefaultOverlayLayers = 3
   };

   struct ParameterStruct
   {
      ParameterStruct() : params(0), isMasterSMS(false) {};
      ParameterStruct(DtVrfObjectParameters* p, bool b, const DtFilename& f) : params(p), isMasterSMS(b), file(f) {};
      ParameterStruct(const ParameterStruct& orig) : params(orig.params), isMasterSMS(orig.isMasterSMS), file(orig.file) {};

      DtVrfObjectParameters* params;
      bool isMasterSMS;
      DtFilename file;
   };

   typedef std::map<DtString, ParameterStruct> ParametersMap;

   typedef DtAmmunitionManager*(*AmmunitionManagerCreator)();

   class EnvironmentContainer
   {
   public:
      EnvironmentContainer();
      EnvironmentContainer(DtEnvironmentSP original);

      virtual ~EnvironmentContainer();

      void seedFrom(DtEnvironmentSP env, DtEnvValueSP root);

      DtEnvironmentSP copyEnvironment(DtEnvironmentSP) const;
      void reparentEnvironmentChildren(DtEnvList*, DtEnvValueSP root) const;

      DtEnvValueSP backup();
      DtEnvValueSP update();

      void remove(DtEnvValueSP originalNode, DtEnvValueSP modifiedNode);
      bool isEmpty() const;

      DtEnvValueSP replace(DtEnvironmentSP env, DtEnvValueSP node, DtEnvValueSP replaceWith);
      void reparentRoots(DtEnvValueSP templateRoot, DtEnvValueSP newRoot) const;

      DtEnvironmentSP myOriginal;
      DtEnvironmentSP myModified;
   };

   typedef boost::shared_ptr<EnvironmentContainer> EnvironmentContainerSP;

   class EntityData : public DtObjectType
   {
   public:
      EntityData();
      virtual ~EntityData();
      EntityData(const DtObjectType& objectType, const DtObjectType& matchType = DtObjectType::nullType());
      EntityData(const EntityData& t);

      //sets the object type
      EntityData& operator=(const DtObjectType&);

      EntityData& operator=(const EntityData&);

      virtual EntityData* clone() const;

      //compares to the object type
      bool operator>(const DtObjectType& rhs) const
      {
         if (*this < rhs)
         {
            return false;
         }
         else
         {
            return true;
         }
      }

      //compares to the object type
      bool operator>(const EntityData& rhs) const
      {
         if (*this < rhs)
         {
            return false;
         }
         else
         {
            return true;
         }
      }

      bool myIsInMasterSMS;
      std::string myDataFile;

      DtEnvValueSP myOriginalDataNode;
      LoadFlags myLoadFlags;
      //this is the environment that includes the parent files (if they exist)
      EnvironmentContainerSP myEnvironment;

      DtSimulationObjectGroupModelSetEntry* myOriginalSOGData;
      DtSimulationObjectGroupModelSetEntry* myModifiedSOGData;

      DtAmmunitionParamsEntry* myOriginalAmmunitionParameters;
      DtAmmunitionParamsEntry* myModifiedAmmunitionParameters;

      DtMunitionDetonationPowerEntry* myOriginalPowerTableEntry;
      DtMunitionDetonationPowerEntry* myModifiedPowerTableEntry;


      DtObjectType myMatchType;
      DtObjectType myOriginalMatchType;

      std::list<DtObjectType> myAdditionalMatchTypes;
      std::list<DtObjectType> myOriginalAdditionalMatchTypes;

      int myLastModifiedDate;
      bool myResolvedParent;

      DtRwVariableBindingsList* myOriginalSystems;
      DtEnvValueSP myOriginalObjectNode;
      DtVariableBindingsList* myOriginalVariableBindings;
      DtFormationTable* myOriginalFormationTable;
      DtVrfSubObjectParameterList* myOriginalSubordinateInformation;
      DtEmbarkationInformation* myOriginalEmbarkationInformation;
      DtDiGuyInformation* myOriginalDiGuyInformation;
      DtSensorSignatureInformation* myOriginalSensorSignatureInformation;
      DtModelSetEntry* myCurrentModelSetEntry;
      DtModelSetEntry* myOriginalModelSetEntry;

      DtRwVariableBindingsList* myModifiedSystems;
      DtEnvValueSP myModifiedObjectNode;
      DtVariableBindingsList* myModifiedVariableBindings;
      DtFormationTable* myModifiedFormationTable;
      DtVrfSubObjectParameterList* myModifiedSubordinateInformation;
      DtEmbarkationInformation* myModifiedEmbarkationInformation;
      DtDiGuyInformation* myModifiedDiGuyInformation;
      DtSensorSignatureInformation* myModifiedSensorSignatureInformation;
      DtVrfObjectParameters* myParameters;
      bool myIsNew;
      bool myIsDeleted;
      bool myIsModified;

      EntityData* myIsReplacing;
      DtSimulationModelSet* mySimulationModelSet;

      DtFilename myParentFile;
      DtEnvironmentSP myParentEnvironment; //this is the environment containing only what is inherited

      std::set<DtString> elementsAddedThisSession;
      std::set<DtVariableBindingsList> systemsAddedThisSession;

      bool hasParentFile()
      {
         if (myParentFile.isEmpty())
         {
            return false;
         }

         return true;
      }
   };

   typedef std::map<std::string, EntityData*> ParametersData;

   typedef std::map<DtArtPartType, DtSimArtPartDescriptor> ArtPartMap;

   DtSimulationModelSetLoader(makVrv::DtDe&);

   virtual ~DtSimulationModelSetLoader();

   virtual bool load(const DtSimulationModelSet&, LoadFlags flags = LoadAll);
   virtual bool save(const DtFilename&);

   static DtSimulationModelSetLoader& instance(makVrv::DtDe&);
   static void registerInstance(makVrv::DtDe&, DtSimulationModelSetLoader*);

   virtual void setDisplayDe(makVrv::DtDe*);
   virtual makVrv::DtDe& displayDe();

private:
   DtSimulationModelSetLoader(const DtSimulationModelSetLoader&);
   DtSimulationModelSetLoader& operator=(const DtSimulationModelSetLoader&);

public:
   virtual void setLoadVisuals(bool);

   virtual bool hasFileNamed(const std::string& s) const;

   virtual bool addNewDataFile(const std::string&, bool useExactFile = false, bool loadInParallel = true, DtString* errorString = nullptr);

   virtual bool addNewSimulationObjectGroup(const std::string&);

   virtual bool addNewRandomizedObject(const std::string&);

   virtual bool readOnly() const;
   virtual void setReadOnly(bool);

   virtual void setSaveReadOnlyFlag(bool);
   virtual bool saveReadOnlyFlag() const;

   virtual bool hasComponentByDescriptorType(const makVrf::DtEntityMapperKey&, const DtString& descriptor) const;
   virtual bool hasComponentByDescriptorType(const DtFilename&, const DtString& descriptor) const;

   virtual bool hasComponentByComponentType(const makVrf::DtEntityMapperKey&, const DtString& descriptor) const;
   virtual bool hasComponentByComponentType(const DtFilename&, const DtString& descriptor) const;

   virtual bool simulationObjectGroupExists(const std::string&) const;

   virtual bool randomizedObjectExists(const std::string&) const;

   virtual DtModelSetEntry* createNewSimulationObjectGroupFromExisting(const DtObjectType& base, const std::string& newName,
      const DtRwNLengthStringVector& categories = DtRwNLengthStringVector("categories"));
   virtual DtModelSetEntry* createNewSimulationObjectGroupFromExisting(EntityData* data, const std::string& newName,
      const DtRwNLengthStringVector& categories = DtRwNLengthStringVector("categories"));
   virtual DtModelSetEntry* createNewAmmunitionEntryFromExisting(EntityData* data, const std::string& newName, const DtEntityType& newType,
      const DtRwNLengthStringVector& categories = DtRwNLengthStringVector("categories"), bool replaceName = false);

   virtual std::string platform(const makVrf::DtEntityMapperKey& k) const;

   virtual std::string uiFilename(const makVrf::DtEntityMapperKey& k) const;

   virtual std::string uiFilename(DtComponentSystemDefinition*) const;

   virtual DtSimulationModelSet* simulationModelSet(const makVrf::DtEntityMapperKey& k) const;

   DtSimulationModelSet* masterSMS() const
   {
      return mySimulationModelSet;
   }

   virtual DtSimulationModelSet* simulationModelSet(const DtComponentSystemDefinition*) const;
   virtual DtSimulationModelSet* simulationModelSet(const DtFilename&) const;

   virtual void setPartialLoad(bool);
   bool partialLoad() const
   {
      return myPartialLoad;
   }

   virtual std::string platformFileType(const makVrf::DtEntityMapperKey& k) const;

   virtual std::string platformKey(const makVrf::DtEntityMapperKey& k) const;

   virtual DtString platformDisplayName(const makVrf::DtEntityMapperKey& k) const;

   virtual DtString platformDisplayDescription(const makVrf::DtEntityMapperKey& k) const;

   virtual bool addMissingVariablesFromPlatformsAndSystems(QWidget* parent = 0, bool saveAllIfAnyModified = false);
   virtual bool addMissingVariablesFromPlatformsAndSystems(EntityData* data, std::map<DtString, DtRwVariableBindings*>&);

   virtual bool addMissingArticulatedParts(QWidget* parent = 0, bool saveIfModified = false);
   virtual bool addMissingArticulatedPartsForEntity(EntityData* data);
   virtual bool addMissingArticulatedPartsForEntity(const DtObjectType& objectType,
      DtSimArtPartDescriptorList* modifiedParts,
      ArtPartMap& partsFromModel, ArtPartMap& partsFromSystemDefaults);

   virtual bool addMissingVariablesAndArticulatedPartsFromPlatformsAndSystems(QWidget* parent = 0, bool saveAllIfAnyModified = false);

   virtual bool getPartsFromEntityVisualModel(const DtObjectType& objectType, ArtPartMap& partsFromModel);

   virtual void regenerateOpeFiles();

   virtual void regenerateSystemFiles();
   virtual std::vector<DtComponentSystemDefinition*> systemsThatCanBeDamagedBy(const DtString&) const;

   virtual DtString rangeTypeFromPower(const DtString&) const;
   virtual void setDefaultRangeTypeForPower(const DtString&, const DtString&);
   virtual std::vector<DtString> rangesByPowerType(const DtString&) const;
   virtual void setSupportedRangesByPowerType(const DtString&, const std::vector<DtString>&);

   virtual std::set<DtString> powerTypes(bool hasHumanActuator) const;
   virtual void addPowerType(const DtString&, const QString& withoutAddition, const QString& withAddition, bool needForceAdditional = false,
      const QString& withoutAdditionX = "", const QString& witAdditionX = "", bool humanOnly = false, bool titleOnly = false);

   virtual QString powerTitle(const DtString&, const QString& addition = "", bool applyAdditionalToAll = false, bool xAxis = false) const;

   virtual void createSupportedDetonations();

   DtFilename getSystemDirectory() const;
   DtFilename getNavDataDirectory() const;
   DtFilename getFormationDirectory() const;
   DtFilename getGuiDirectory() const;
   DtFilename path() const;

   DtFilename simulationModelSetFilename() const;

   virtual bool checkAndLoadAll(QString text = "");

   virtual bool openSystemFiles(DtSimulationModelSet* set, const DtFilename& directory, bool isInMasterSMS);

   virtual DtString cleanStringForRwSymbol(const DtString&) const;

   virtual bool loadForceHostilityFile(const DtFilename& f);
   virtual bool loadAmmunitionParameters(const DtFilename& f, bool inMasterSMS, DtSimulationModelSet* sms);
   virtual bool loadDetonationParameters(const DtFilename& f, bool inMasterSMS, DtSimulationModelSet* sms);

   virtual bool loadDetTerrainDeformParameters(const DtFilename& f, bool inMasterSMS, DtSimulationModelSet* sms);

   virtual bool loadDataFiles(const DtString&, DtSimulationModelSet*, bool fromMasterSMS, LoadFlags flags = LoadAll);

   virtual void loadSimulationObjectGroupFiles(const DtString&, DtSimulationModelSet*, bool fromMasterSMS);

   virtual DtModelSetEntry* reloadSimulationObjectGroup(const DtString&);

   virtual void loadTemplates(const DtString&, DtSimulationModelSet*);

   virtual std::vector<DtComponentSystemDefinition*> systemsThatUseAmmunition(const DtString&) const;
   virtual std::vector<DtComponentSystemDefinition*> systemsThatUseTemplate(const DtFilename&) const;

   virtual void makeTemplate(EntityData*);
   virtual void makeTemplate(const DtObjectType&);

   virtual bool itemContains(const DtVrfSubObjectParameterList&, const DtObjectType&) const;

   virtual const std::vector<DtString>& iconLists() const;
   virtual bool hasIconList(const DtString&) const;

   virtual void addIconList(const DtString&);
   virtual void removeIconList(const DtString&);
   virtual void setIconLists(const std::vector<DtString>&);
   virtual void loadIconLists(const DtFilename&);
   virtual void saveIconLists(const DtFilename&);

   virtual bool loadParameterFiles(DtSimulationModelSet* sms, bool inMasterSMS);

   virtual bool loadModelSet();

   virtual DtModelSetEntry* modelEntry(const DtObjectType&, bool matchPattern = false) const;

   virtual DtFilename modelDefinitionFile(const DtObjectType&, bool resolve) const;
   virtual const makVrv::DtModelDefinition* modelDefinition(const DtObjectType& objectType, std::string& definition) const;
   virtual std::string diGuyCharacterOMMX() const;
   virtual std::string diGuyCharacterLeaf() const;

   virtual DtString simulationModelSetFor(const DtEntityType&) const;

   virtual DtString simulationModelSetFor(const DtFilename&) const;

   virtual DtModelSetEntry* createModelSetEntryFrom(DtEnvironmentSP env, DtEnvValueSP objectNode) const;
   virtual DtModelSetEntry* createModelSetEntryFrom(const DtObjectType&) const;
   virtual DtModelSetEntry* createModelSetEntryFrom(const DtAmmunitionParamsEntry*) const;

   virtual bool hasGuiKeyword(const makVrf::DtEntityMapperKey&, const std::string&) const;

   virtual void revertData(const makVrf::DtEntityMapperKey& key);
   virtual void revertData(DtComponentSystemDefinition*);

   virtual DtVrfObjectParameters* objectParameterDataFor(const DtObjectType& o) const;

   virtual EntityData* dataFor(const DtObjectType&, bool completeLoadIfNecessary = true) const;

   virtual EntityData* dataFor(DtModelSetEntry*, bool completeLoadIfNecessary = true) const;

   virtual bool containsObjectType(const DtObjectType&, bool onlyFromMasterSMS = false, DtString* name = 0) const;

   virtual DtVariableBindingsList allVariableBindingsInSystemsFor(const DtObjectType&) const;

   virtual bool isSimulationObjectGroup(const DtObjectType&) const;

   virtual bool hasModelNamed(const DtString&, bool& isDeleted);

   virtual DtReaderWriter::SearchPaths searchPaths() const;
   virtual std::vector<DtSimulationModelSet*> modelSets() const;

   virtual QString ammunitionDisplayName(const DtEntityType&) const;

   virtual const ParametersMap& availableParameters() const
   {
      return myAvailableParameters;
   }

   virtual bool hasHumanDamageSystem(const std::vector<DtComponentSystemDefinition*>&) const;

   virtual bool createRwVariable(const DtObjectType&, const std::string& rwType, const std::string& rwName, DtReaderWriter*& original,
      DtReaderWriter*& modified);

   virtual void replaceSystem(const DtFilename&);

   virtual bool entryIsRandomized(const DtObjectType&) const;
   virtual bool canAddSubordinatesTo(const DtObjectType&) const;

   virtual bool isModified(const DtObjectType&) const;
   virtual bool isModified(EntityData*) const;
   virtual bool isModified(DtComponentSystemDefinition*) const;

   virtual bool isModified(const DtFilename&) const;

   virtual bool isModified() const;

   virtual bool isNew(const DtObjectType&) const;
   virtual bool isNew(EntityData*) const;

   virtual bool isDeleted(const DtObjectType&) const;
   virtual bool isDeleted(EntityData*) const;

   virtual bool isDeleted(DtComponentSystemDefinition*) const;
   virtual bool isDeleted(const DtFilename&) const;

   virtual bool isNew(DtComponentSystemDefinition*) const;
   virtual bool isNew(const DtFilename&) const;

   virtual std::vector<EntityData*> objectsThatUseSystems(const std::vector<DtComponentSystemDefinition*>& rw) const;

   virtual makVrf::DtVrfEntityTypeMapper& entityTypeMapper(const makVrf::DtEntityMapperKey&);
   virtual makVrf::DtVrfEntityTypeMapper& aggregateTypeMapper(const makVrf::DtEntityMapperKey&);
   virtual makVrf::DtVrfEntityTypeMapper& tacticalGraphicsMapper(const makVrf::DtEntityMapperKey&);
   virtual makVrv::DtElementDefinitionTypeManager& elementDefinitionTypeManager(const makVrf::DtEntityMapperKey&);
   virtual makVrv::DtModelDefinitionManager& modelDefinitionManager(const makVrf::DtEntityMapperKey&);

   virtual void saveModelDefinitionManager();
   virtual void saveVisualElementsFor(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, bool andHierarchy = false);
   virtual makVrf::DtVrfVisualsManager* visualsManager();

   virtual makVrf::DtVrfEntityTypeMapper& defaultEntityTypeMapper();
   virtual makVrf::DtVrfEntityTypeMapper& defaultAggregateTypeMapper();
   virtual makVrf::DtVrfEntityTypeMapper& defaultTacticalGraphicsMapper();
   virtual makVrv::DtElementDefinitionTypeManager& defaultElementDefinitionTypeManager();
   virtual makVrv::DtModelDefinitionManager& defaultModelDefinitionManager();

   virtual makVrv::DtEntityTypeMapper* systemEntityTypeMapper();
   virtual makVrv::DtEntityTypeMapper* systemAggregateTypeMapper();
   virtual makVrv::DtEntityTypeMapper* systemTacticalGraphicsMapper();
   virtual makVrv::DtElementDefinitionTypeManager& systemElementDefinitionTypeManager();
   virtual makVrv::DtModelDefinitionManager& systemModelDefinitionManager();

   virtual void createSpotReportDefinitionFor(const makVrf::DtEntityMapperKey&);
   virtual void updateVisualsFor(const makVrf::DtEntityMapperKey&);
   virtual void removeVisualsFor(const makVrf::DtEntityMapperKey&);
   virtual void removeElementDefinition(const makVrf::DtEntityMapperKey&);

   virtual void deleteModel(DtModelSetEntry*);
   virtual void deleteModel(const DtObjectType&);
   virtual void deleteModel(EntityData*);

   virtual void deleteSystem(const DtComponentSystemDefinition*);
   virtual void deleteSystem(const DtFilename&);

   virtual bool deleteSystemFromModelSet(const DtComponentSystemDefinition*);

   virtual bool changeObjectType(const DtObjectType& oldType, const DtObjectType& newType);

   virtual bool changeMatchType(const DtObjectType& oldType, const DtObjectType& newType);

   virtual bool setAdditionalMatchTypes(const DtObjectType& key, const std::list<DtObjectType> additionalMatchTypes);

   virtual std::vector<DtString> updateGuiInformation(EntityData*, DtEnvValueSP = DtEnvValueSP());

   virtual void updateSystemData(EntityData*);

   virtual void sharedSystems(const DtFilename& systemFile, std::vector<DtModelSetEntry*>& result) const;

   virtual void updateDataInformation(EntityData*);

   virtual DtEnvironmentSP resolveParentData(EntityData*);

   virtual void convertRegistryToEnvironment(const DtReaderWriterRegistry& data, DtEnvironmentSP env, DtEnvValueSP objectNode) const;

   virtual void removeSystem(DtEnvironmentSP env, const DtString& system, DtEnvValueSP objectNode);

   virtual void addSystem(DtEnvironmentSP env, const DtRwVariableBindings*, DtEnvValueSP objectNode);

   virtual const QStringList& masterModeCategories(CategoryTypes) const;
   virtual QStringList& masterModeCategories(CategoryTypes);
   virtual QStringList defaultCategoriesAsStringList(CategoryTypes) const;

   DtSimulationObjectCategoryInformation& defaultCategories(CategoryTypes);
   const DtSimulationObjectCategoryInformation& defaultCategories(CategoryTypes) const;

   DtSimulationObjectCategoryInformation& nonMasterModeCategories(CategoryTypes);
   const DtSimulationObjectCategoryInformation& nonMasterModeCategories(CategoryTypes) const;

   virtual void loadAutoTagInformation();

   DtAutoTagInformation& autoTagInformation();
   const DtAutoTagInformation& autoTagInformation() const;

   virtual int getFileCount(const DtSimulationModelSet&) const;

   virtual void setDefaultCategories(const DtSimulationObjectCategoryInformation&, const QStringList& masterMode, CategoryTypes);
   virtual void revertCategories(CategoryTypes);
   virtual bool hasModifiedCategories(CategoryTypes) const;
   virtual bool saveDefaultCategories(const DtFilename&, CategoryTypes);
   virtual bool loadDefaultCategories(const DtFilename&, CategoryTypes);

   void setDefaultOverlayLayers(const QStringList&);
   const QStringList& defaultOverlayLayers();
   virtual void revertOverlayLayers();
   virtual bool hasModifiedOverlayLayers() const;
   virtual void changeDefaultOverlayLayer(const QString& old, const QString& newCat);
   virtual void addDefaultOverlayLayers(QComboBox*);
   void addDefaultOverlayLayer(const QString&);

   virtual DtRwForces favoritesFor(const DtModelSetEntry*) const;
   virtual DtRwForces backupFavoritesFor(const DtModelSetEntry*) const;
   virtual void setFavoritesFor(DtModelSetEntry*, const DtRwForces&);

   virtual void changeDefaultDeployedCountry(const QString& old, const QString& newCat);
   void setDefaultDeployedCountries(const QStringList&);
   void addDefaultDeployedCountry(const QString&);
   const QStringList& defaultDeployedCountries();
   virtual void revertDeployedCountries();
   virtual bool hasModifiedDeployedCountries() const;

   virtual void resetVisuals();

   virtual DtRwVariableBindings* createVariableBindingsForSystem(const DtFilename&, const DtString& newSystemName);

   virtual std::map<std::string, DtEntityType> templatesForKind(int) const;
   virtual std::map<std::string, DtEntityType> templatesThatMatch(const DtEntityType&) const;

   virtual DtModelSetEntry* addNewEntity(const DtObjectType& base, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID, const makVrv::DtUnicode& elementDefinition = makVrv::DtUnicode::fromAscii(""),
      bool replaceAmmoName = false);

   virtual DtModelSetEntry* addNewEntity(const std::string& platformType, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID, const makVrv::DtUnicode& elementDefinition = makVrv::DtUnicode::fromAscii(""));

   virtual DtModelSetEntry* addNewEntity(EntityData* baseData, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID, const makVrv::DtUnicode& elementDefinition = makVrv::DtUnicode::fromAscii(""),
      bool replaceAmmoName = false);

   virtual DtModelSetEntry* addNewInheritingEntity(const DtObjectType& parent, const DtObjectType& type, const DtString& name);

   virtual void addGuiInfo(EntityData*, DtModelSetEntry*, const DtString& name, const DtObjectType&,
      const DtRwNLengthStringVector& categories, const DtString uniqueId);

   virtual void removeSystem(const DtFilename&);

   virtual const DtRwVariableBindings* variableBindings() const;

   virtual QPixmap getIcon(const makVrf::DtEntityMapperKey& key, int pointSize = 48,
      bool sizeToFont = false);

   virtual QPixmap getUnfilledIcon(const makVrf::DtEntityMapperKey& key, const QColor& outlineColor = Qt::black, const QColor& fillColor = Qt::transparent, int pointSize = 48,
      bool sizeToFont = false);

   virtual void clearIcons(const makVrf::DtEntityMapperKey& key);

   static DtSimulationModelSetLoader* create(makVrv::DtDe*);

   virtual void changeSubordinateTypes(const DtObjectType& oldType, const DtObjectType& newType);

   virtual void checkParameterUpdates(EntityData*);
   virtual void checkParameterUpdates(const std::set<makVrf::DtEntityMapperKey>&);

   virtual makVrv::DtUnicode elementDefinitionFor(const DtEntityType&);

   virtual DtVrfSubObjectParameterList subordinateObjectsFor(const DtObjectType&) const;
   virtual DtVrfSubObjectParameterList subordinateObjectsFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateSubordinateObjects(const DtObjectType&, const DtVrfSubObjectParameterList&);
   virtual void updateSubordinateObjects(DtEnvironmentSP, DtEnvValueSP objectNode, const DtVrfSubObjectParameterList&);

   virtual void updateFormationTable(const DtObjectType&, const DtFormationTable&);

   virtual DtEmbarkationInformation embarkationInformationFor(const DtObjectType&) const;
   virtual DtEmbarkationInformation embarkationInformationFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateEmbarkationInformation(const DtObjectType&, const DtEmbarkationInformation&);
   virtual void updateEmbarkationInformation(DtEnvironmentSP, DtEnvValueSP objectNode, const DtEmbarkationInformation&);

   virtual DtDiGuyInformation diGuyInformationFor(const DtObjectType&) const;

   virtual void updateDiGuyInformation(const DtObjectType&, const DtDiGuyInformation&);

   virtual DtSensorSignatureInformation sensorSignatureInformationFor(const DtObjectType&) const;
   virtual DtSensorSignatureInformation sensorSignatureInformationFor(DtEnvironmentSP, DtEnvValueSP root) const;

   virtual void updateSensorSignatureInformation(const DtObjectType&, const DtSensorSignatureInformation&);
   virtual void updateSensorSignatureInformation(DtEnvironmentSP, DtEnvValueSP root, const DtSensorSignatureInformation&);

   virtual DtFormationTable* formationTableFor(const DtObjectType&);
   virtual DtFormationTable* originalFormationTableFor(const DtObjectType&);

   virtual Dt3dBoundingVolume boundingVolumeFor(const DtObjectType&) const;

   virtual bool isAggregate(const DtObjectType&) const;

   bool loaded() const
   {
      return myLoaded;
   }

   const DtOrderedObjectTypeList<EntityData*>& entityData() const
   {
      return myEntityData;
   }

   bool cancelledLoad() const
   {
      return myCancelledLoad;
   }

   virtual bool isTemplate(const DtObjectType&) const;
   virtual bool templateExists(const DtObjectType&) const;

   virtual void setForceManagerModified(bool);
   virtual bool forceManagerModified() const;

   virtual DtFilename modelDefinitionsPath();

   virtual bool upgradeCountriesToCountryCodes(EntityData*);

   virtual bool isInMasterSMS(const DtObjectType&) const;
   virtual bool isInMasterSMS(const DtFilename&) const;
   virtual bool isInMasterSMS(const DtComponentSystemDefinition*) const;

   virtual DtString smsName(const DtObjectType&) const;
   virtual DtString smsName(const DtFilename&) const;
   virtual DtString smsName(const DtComponentSystemDefinition*) const;

   virtual const DtComponentSystemDefinition* originalSystemDefinitionFor(const DtComponentSystemDefinition*) const;
   virtual const DtComponentSystemDefinition* originalSystemDefinitionFor(const DtFilename&) const;

   virtual bool saveData();
   virtual bool saveData(EntityData* data, bool force = false);
   virtual bool saveUserRangeRings();

   virtual bool saveFavorites();

   virtual bool saveSystems();

   virtual DtEnumDictionary* userRangeRingIds();
   virtual DtFilename userRangeIdEnumerationFile() const;
   
   virtual void userRangeRingsChanged();

   virtual bool saveAmmunitionTable();

   virtual bool saveDetonationTable();

   virtual bool saveDetonationTerrainDeformationTable();

   virtual DtObjectType templateObjectType(const std::string& parameterType) const;

   virtual void addInternalItem(const std::string&, bool markDataAsWell = true);

   virtual void addIgnorePlatformType(const DtString&);

   virtual QString parameterDisplayName(const DtString& parameterType, bool stopAtFirst = true) const;

   virtual std::map<DtString, QString> availableParameterTypes(const std::set<std::string>& except = std::set<std::string>()) const;

   virtual std::vector<DtReaderWriter*> supportPointsFor(const DtObjectType&) const;

   virtual DtObjectType uniqueEntityTypeFrom(const DtObjectType&, bool onlyFromMasterSMS = false) const;

   virtual makVrv::DtUnicode systemNameForSystem(const std::string&, DtFilename& fullFilename) const;

   virtual bool hasFactoryChecksums() const;

   virtual const DtSmsChecksum& factoryChecksums() const;

   virtual DtRwVisualMetaData* addOrUpdateVisualMetaData(const DtEntityType&);

   virtual DtComponentSystemDefinition* duplicateSystem(const DtComponentSystemDefinition* base, const DtString& systemName, const DtFilename& systemFilename);

   virtual DtComponentSystemDefinition* createFromTemplate(const DtString& systemName, const DtFilename& systemFilename, const DtComponentSystemDefinition* systemTemplate);
   virtual DtFilename filenameToSystemFilename(DtFilename systemFilename) const;

   virtual void promoteSystem(DtComponentSystemDefinition*);

   virtual std::map<DtSymbolString, DtAmmunitionParamsEntry*> ammunitionTable() const;

   virtual DtAmmunitionParamsEntry* addAmmunition(const DtString& name, const DtString& label, const DtObjectType& munitionType);

   virtual DtAmmunitionParamsEntry* ammunitionEntry(const DtSymbolString&) const;
   virtual DtAmmunitionParamsEntry* ammunitionEntry(const DtObjectType&) const;

   virtual DtMunitionDetonationPowerEntry* detonationPowerEntry(const DtObjectType&) const;

   virtual std::set<DtEntityType> detonationTypes() const;
   virtual DtMunitionDetonationPowerEntry* duplicatePowerEntry(const DtObjectType&, const DtEntityType&);

   virtual std::vector<const DtComponentSystemDescriptor*> matchingSystemDescriptors(const makVrf::DtEntityMapperKey&, const DtComponentSystemDescriptor* fromSystemDatabase,
      const DtString& systemPath) const;
   virtual std::vector<const DtComponentSystemDescriptor*> matchingSystemDescriptors(const DtComponentSystemDescriptor* fromEntity, const DtComponentSystemDescriptor* fromSystemDatabase,
      DtString currentPath, const DtString& systemPathToCheck) const;

   virtual std::vector<DtTargetingControlTable*> getTargetingControlTables(const makVrf::DtEntityMapperKey&) const;

   virtual std::map<DtComponentSystemDefinition*, const DtRangeProbabilityTable*> getSystemsAndHitTables() const;

   typedef std::map<const DtComponentSystemDefinition*, std::pair<const DtTargetingControlTable*,
      const DtRangeProbabilityTable*> > TargetingControlAndRangeTables;
   virtual TargetingControlAndRangeTables getTargetingControlAndRangeTables(const makVrf::DtEntityMapperKey&) const;

   struct AmmunitionInformation
   {
      AmmunitionInformation() : controlTable(0), maximumRange(0.) {};
      AmmunitionInformation(const DtTargetingControlTable* c, double r) : controlTable(c), maximumRange(r) {};
      AmmunitionInformation(const AmmunitionInformation& orig) : controlTable(orig.controlTable), maximumRange(orig.maximumRange) {};

      const DtTargetingControlTable* controlTable;
      double maximumRange;
   };

   typedef std::map<const DtAmmunitionParamsEntry*, AmmunitionInformation> AmmunitionMap;
   virtual AmmunitionMap ammunitionFromTargetTables(const DtSimulationModelSetLoader::TargetingControlAndRangeTables& targets) const;

   virtual void findAllTargetingControlAndRangeTables(const DtString&, TargetingControlAndRangeTables&) const;

   virtual DtRwDamageByMunitionPowerMap* damageTableFor(const makVrf::DtEntityMapperKey&, DtComponentSystemDefinition** system = 0) const;

   virtual QString translatedSystemName(const DtComponentSystemDefinition* definition) const;
   virtual QString translatedSystemDescription(const DtComponentSystemDefinition* definition) const;

   virtual DtObjectType ammunitionType(const DtSymbolString&) const;

   virtual QString ammunitionDisplayName(const DtSymbolString&) const;
   virtual void setAmmoEntryIfNecessary(EntityData* data, const DtAmmunitionParamsEntry* templateEntry = 0);

   virtual bool ammunitionCanTarget(const DtSymbolString&, const DtEntityType&) const;

   void setNeedsPruning(bool b) { myNeedsPruning = b; };
   bool needsPruning() const
   {
      return myNeedsPruning;
   }

   boost::signals2::signal<void()> signal_preloadSimulationModelSet;
   boost::signals2::signal<void()> signal_simulationModelSetLoaded;
   boost::signals2::signal<void(std::vector<EntityData*>)> signal_newDataFileAdded;
   boost::signals2::signal<void(EntityData*)> signal_entityEntryAboutToBeRemoved;
   boost::signals2::signal<void(EntityData*)> signal_entityEntryAdded;
   boost::signals2::signal<void(EntityData*)> signal_visualMappingsModified;
   boost::signals2::signal<void()> signal_resetVisuals;
   boost::signals2::signal<void(bool)> signal_readOnlyChanged;
   boost::signals2::signal<void(DtComponentSystemDefinition*)> signal_systemEntryAdded;
   boost::signals2::signal<void(const DtFilename&)> signal_systemRemoved;
   boost::signals2::signal<void(DtComponentSystemDefinition*)> signal_systemAboutToBeRemoved;
   boost::signals2::signal<void(const DtObjectType&, const DtObjectType&)> signal_objectTypeAboutToBeChanged;
   boost::signals2::signal<void(const DtObjectType&, const DtObjectType&)> signal_objectTypeChanged;

   boost::signals2::signal<void(makVrv::DtDe*)> signal_displayDeSet;

public:
   const DtModelSet* modelSet() const;
   DtModelSet* modelSet();

   virtual makVrf::DtVrfGuiForceManager* forceManager();

   const DtSimulationModelSet& simulationModelSet() const;
   bool hasSimulationModelSet() const;
   DtSimulationModelSet& simulationModelSet();
   const DtFilename& parameterFilename() const;
   const DtSimulationObjectEditorComponentSystemDatabase* originalSystemDatabase() const;
   const DtSimulationObjectEditorComponentSystemDatabase* modifiedSystemDatabase() const;
   const DtSimulationObjectEditorComponentSystemDatabase* templateSystemDatabase() const;
   DtSimulationObjectEditorComponentSystemDatabase* modifiedSystemDatabase();
   DtFilename modelSetDirectory() const;

   virtual void forceRemoved(DtForceType forceType);

   const DtRwForces& allForces() const;

   virtual std::vector<const DtComponentSystemDefinition*> systemDefinitionsFor(const DtObjectType& o) const;
   virtual std::vector<const DtComponentSystemDefinition*> systemDefinitionsFor(const DtObjectType& o, const DtString& category) const;

   virtual const DtReaderWriter* findVariable(const DtVariableBindingsList&, const DtString&) const;
   virtual const DtReaderWriter* findOriginalVariable(const makVrf::DtEntityMapperKey& emk, const DtString&) const;
   virtual const DtReaderWriter* findModifiedVariable(const makVrf::DtEntityMapperKey& emk, const DtString&, bool completeLoadIfNecessary = true) const;
   virtual DtReaderWriter* findVariable(const DtVariableBindingsList&, const DtString&);
   virtual DtReaderWriter* findOriginalVariable(const makVrf::DtEntityMapperKey& emk, const DtString&);
   virtual DtReaderWriter* findModifiedVariable(const makVrf::DtEntityMapperKey& emk, const DtString&, bool completeLoadIfNecessary = true);
   virtual const DtReaderWriter* variableFromAnyPlatform(const DtString& varName) const;

   virtual void addModifiedVariable(const makVrf::DtEntityMapperKey& emk, DtReaderWriter* rw);

   virtual DtVrfObjectParameters* platformParameters(const makVrf::DtEntityMapperKey& key) const;

   virtual const DtStandardSensorObjects& standardSensorObjects() const;
   virtual DtStandardSensorObjects& standardSensorObjects();
   virtual bool processModelSet(DtSimulationModelSet*, LoadFlags flags = LoadAll, bool isMasterSMS = false);

   virtual std::vector<EntityData*> addDataFromFile(const DtString& file, 
      DtSimulationModelSet* set, bool isMasterSMS,
      bool signalAddition = true, bool isTemplate= false, LoadFlags flags = LoadAll, bool loadInParallel = true, DtString* errorResult = nullptr);

   virtual DtVariableBindingsList* copyBindingsList(const DtVariableBindingsList* orig) const;
   
   virtual void getSubordinateFunctions(DtSubordinateFunctionTable& functions) const;

   virtual const std::vector<DtSubordinateFunctionTable>& subordinateFunctionTables() const;
   virtual std::vector<DtSubordinateFunctionTable>& subordinateFunctionTables();

   virtual EntityData* completeDataIfNecessary(EntityData* data);

protected:
   virtual bool updateRangeNameAndRangeId(DtVariableBindingsList* data);

   virtual void replaceVariableNamesWithUpdatedVariableNames(DtRwVariableBindings*, const DtComponentSystemDefinition*);

   virtual void markInternalItemsAsReadOnly(DtVariableBindingsList*);

   virtual const DtReaderWriter* findVariable(const DtString& var, const DtReaderWriter* rw) const;

   virtual void loadSystemFilesFromDirectory(const QString& directoryName, const DtVariableBindingsList& variableBindings, DtSimulationModelSet*, bool isInMasterSMS,
      bool loadTemplates = false);

   virtual void addVariableReferences(DtReaderWriter* source, DtRwVariableBindings* toBindings) const;

   virtual void cleanup();
   virtual bool ignorePlatformType(const DtString&) const;

   virtual bool saveForceHostility(const DtFilename& filename);

   virtual bool warned(const DtFilename&);
   virtual void removeEntityFromSubObjects(const DtObjectType&);

   virtual void mergeFavoritesIntoModelSet(DtModelSet* favorites, DtModelSet* set);

   virtual void setupParametersForDataFiles(std::vector<EntityData*>&, DtSimulationModelSet* set);

   virtual EntityData* createParameterDataFrom(DtVrfObjectParameters*) const;

   virtual bool updateFromPlatform(EntityData* data, const DtReaderWriter* oldRegData, DtEnvironmentSP env, DtEnvValueSP objectNode) const;

   virtual bool traverseRwObject(const DtReaderWriter* rwObject, DtEnvironmentSP env, DtEnvValueSP objectNode) const;
   virtual void addElementFromSystemBinding(DtEnvironmentSP env,
      DtEnvValueSP parentElement, DtSystemParameterData* paramData) const;

   virtual DtFormationTable* formationTableFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateFormationTable(DtEnvironmentSP, DtEnvValueSP objectNode, const DtFormationTable&);

public:
   virtual void addToInternalCategories(DtModelSetEntry* entry, bool isInMasterSMS);

   virtual DtModelSetEntry* addModelSetEntryFromEnvironment(DtEnvironmentSP, DtEnvValueSP node);
   virtual DtModelSetEntry* addModelSetEntryFromSimulationObjectGroup(EntityData*);

   virtual void swapCurrentEntry(EntityData*, DtModelSetEntry*);

protected:
   virtual void cancelLoad();
   virtual void addToInternalCategories(const DtComponentSystemDefinition* entry, bool isInMasterSMS);

   virtual void addEntityDataEntry(EntityData*, bool signal = true);
   virtual void removeEntityDataEntry(EntityData*, bool signal = true, bool removeFromVisualsToo = true);

   virtual ParametersMap::const_iterator findAvailablePlatform(const DtString& platform) const;
   virtual ParametersData::const_iterator findAvailableParameter(const DtString& platform) const;
   virtual ParametersData::const_iterator findAvailableParameterFromFile(const DtFilename& platform) const;
   virtual ParametersData::const_iterator findAvailableParameterType(const DtString& parameterType) const;

   virtual DtString filenameFromEntityName(const DtString& name) const;

   virtual DtString uniqueEntityFilename(const DtString& name) const;

   virtual void loadVisuals(DtSimulationModelSet*, bool createIfDoesNotExist = false);

   virtual bool updateAndAddMatchTypeVisuals(EntityData* baseType, const DtEntityType& matchType);

   virtual bool removeMatchingTypeFromVisuals(const DtEntityType& matchType);

   virtual void finalizeCategoryInformationFor(const DtSimulationModelSet& sms, CategoryTypes type = EntityCategories);

   virtual DtFilename categoryFilename(const DtSimulationModelSet& sms, CategoryTypes type = EntityCategories) const;

   static DtAmmunitionManager* createAmmunitionManager();
   static void setAmmunitionManagerCreator(AmmunitionManagerCreator creator);

   virtual void convertAmmunitionToEntityData(DtAmmunitionParams*, bool inMasterSMS, DtSimulationModelSet* sms);
   virtual DtAmmunitionParams* createAmmunitionParameters() const;
   virtual DtDetonationParams* createDetonationParameters() const;

   virtual DtTerrainDeformationParams* createDetonationTerrainDeformationParams() const;

   virtual void getPartsFromModel(const DtObjectType& objectType, std::list<DtSimArtPartDescriptor>& artParts);
   virtual void parsePowerTypes();

protected:

   DtSimulationModelSetLoadProgressWidget* myProgressWidget;

   QStringList myWarned;
   DtSimulationModelSet* mySimulationModelSet;
   DtSimulationObjectEditorComponentSystemDatabase* myOriginalSystemDatabase;
   DtSimulationObjectEditorComponentSystemDatabase* myModifiedSystemDatabase;
   DtSimulationObjectEditorComponentSystemDatabase* myTemplateSystems;

   typedef std::map<DtFilename, bool> SystemIsInMasterSMSMap;
   SystemIsInMasterSMSMap mySystemIsInMasterSMSMap;

   DtFilename        myParameterFilename;
   DtModelSet*       myModelSet;
   DtRwForces        myAllForces;

   typedef std::map<int, DtSimulationObjectCategoryInformation> CategoriesMap;
   CategoriesMap       myDefaultCategories;
   CategoriesMap       myNonMasterModeCategories;
   CategoriesMap       myOriginalDefaultCategories;

   typedef std::map<int, QStringList> StringCategoriesMap;
   StringCategoriesMap myMasterModeCategories;
   StringCategoriesMap myOriginalMasterModeCategories;
   QStringList       myDefaultOverlayLayers;
   QStringList       myDefaultDeployedCountries;
   makVrv::DtDe&     myDe;
   makVrv::DtDe*     myDisplayDe;
   bool myLoaded;
   DtStandardSensorObjects myStandardSensorObjects;
   DtAmmunitionManager* myAmmunitionManager;

   DtEnumLoader* myEnumLoader = nullptr;
   DtEnumDictionary* myUserRangeRingIds = nullptr;
   bool myUserRangeRingsChanged = false;

   DtDetonationParams* myMasterModeDetonationParameters;
   DtDetonationParams* myDetonationParameters;

   DtTerrainDeformationParams *myMasterModeDetTerrainDeformParameters;
   DtTerrainDeformationParams *myDetonationTerrainDeformationParameters;

   DtOrderedObjectTypeList<EntityData*> myEntityData;

   DtSimulationObjectEditorScenarioExplorer* myScenarioExplorer;

   ParametersMap myAvailableParameters;
   ParametersData myParametersData;

   std::set<std::string> myInternalItems;
   std::set<DtString> myIgnorePlatformType;
   DtModelSet* myFavoritesModelSet;
   DtModelSet* myBackupFavoritesModelSet;

   typedef std::map<DtModelSetEntry*, EntityData*> EntityDataByEntry;
   EntityDataByEntry myEntityDataByEntry;

   std::vector<QTranslator*> myTranslators;
   bool myForceManagerModified;

   makVrf::DtVrfVisualsManager* myVrfVisualsManager;

   std::map<DtString, int> myMatchingVisualTypes;
   bool myLoadVisuals;

   DtAutoTagInformation myAutoTagInformation;
   bool myReadOnly;
   bool myLoadingSMSFiles;

   int myTotalNumberOfEntityFiles;

   DtSmsChecksum myFactorySmsChecksum;
   bool mySaveReadOnlyFlag;
   bool myCancelledLoad;

   mutable std::string myDiGuyCharacterOMMX;
   mutable std::string myDiGuyCharacterLeaf;

   std::map<DtString, DtString> myDefaultRangeForPowerType;
   std::map<DtString, std::vector<DtString> > mySupportedRangesByPowerType;
   std::vector<bool> myNeedsSort;

   struct PowerTitle
   {
      QString withoutAdditionX;
      QString withAdditionX;
      QString withoutAdditionY;
      QString withAdditionY;
      bool needsForceAddition;
      bool humanOnly;
      bool titleOnly;
   };

   std::vector<DtString> myIconLists;
   std::vector<DtString> myOriginalIconLists;
   std::map<DtString, PowerTitle> myPowerTypes;
   std::vector<DtSubordinateFunctionTable> mySubordinateFunctionTables;
   bool myNeedsPruning;
   bool myPartialLoad;
   bool myLoadedAllFromPartialLoad;
   tbb::mutex myDataEntryMutex;
   tbb::mutex myAddToInternalCategoriesMutex;
   tbb::spin_mutex mySwapCurrentEntryMutex;

   static AmmunitionManagerCreator theAmmunitionManagerCreator;

   DtVrfCallbackQueue myDataJobLoader;
};

inline DtFilename DtSimulationModelSetLoader::simulationModelSetFilename() const
{
   if (mySimulationModelSet)
   {
      return mySimulationModelSet->filename();
   }
   else
   {
      return "";
   }
}

inline bool DtSimulationModelSetLoader::hasSimulationModelSet() const
{
   return (mySimulationModelSet != 0);
}

inline const DtSimulationModelSet& DtSimulationModelSetLoader::simulationModelSet() const
{
   return *mySimulationModelSet;
}

inline DtSimulationModelSet& DtSimulationModelSetLoader::simulationModelSet()
{
   return *mySimulationModelSet;
}

inline const DtModelSet* DtSimulationModelSetLoader::modelSet() const
{
   return myModelSet;
}

inline DtModelSet* DtSimulationModelSetLoader::modelSet()
{
   return myModelSet;
}

inline const DtFilename& DtSimulationModelSetLoader::parameterFilename() const
{
   return myParameterFilename;
}

inline const DtRwForces& DtSimulationModelSetLoader::allForces() const
{
   return myAllForces;
}

inline const DtAutoTagInformation& DtSimulationModelSetLoader::autoTagInformation() const
{
   return myAutoTagInformation;
}

inline DtAutoTagInformation& DtSimulationModelSetLoader::autoTagInformation()
{
   return myAutoTagInformation;
}

inline const DtSimulationObjectCategoryInformation& DtSimulationModelSetLoader::defaultCategories(CategoryTypes type) const
{
   CategoriesMap::const_iterator iter = myDefaultCategories.find(type);

   return iter->second;
}

inline DtSimulationObjectCategoryInformation& DtSimulationModelSetLoader::defaultCategories(CategoryTypes type)
{
   return myDefaultCategories[type];
}

inline const DtSimulationObjectCategoryInformation& DtSimulationModelSetLoader::nonMasterModeCategories(CategoryTypes type) const
{
   CategoriesMap::const_iterator iter = myNonMasterModeCategories.find(type);

   return iter->second;
}

inline DtSimulationObjectCategoryInformation& DtSimulationModelSetLoader::nonMasterModeCategories(CategoryTypes type)
{
   return myNonMasterModeCategories[type];
}

inline const QStringList& DtSimulationModelSetLoader::defaultOverlayLayers()
{
   if (myNeedsSort[DefaultOverlayLayers])
   {
      myNeedsSort[DefaultOverlayLayers] = false;
      myDefaultOverlayLayers.sort();
   }

   return myDefaultOverlayLayers;
}

inline void DtSimulationModelSetLoader::setDefaultOverlayLayers(const QStringList& l)
{
   myDefaultOverlayLayers = l;
}

inline void DtSimulationModelSetLoader::addDefaultOverlayLayer(const QString& l)
{
   myDefaultOverlayLayers.push_back(l);
}

inline const QStringList& DtSimulationModelSetLoader::defaultDeployedCountries()
{
   if (myNeedsSort[DefaultDeployableCountries])
   {
      myNeedsSort[DefaultDeployableCountries] = false;
      myDefaultDeployedCountries.sort();
   }

   return myDefaultDeployedCountries;
}

inline void DtSimulationModelSetLoader::setDefaultDeployedCountries(const QStringList& l)
{
   myDefaultDeployedCountries = l;
}

inline void DtSimulationModelSetLoader::addDefaultDeployedCountry(const QString& l)
{
   myDefaultDeployedCountries.push_back(l);
   myDefaultDeployedCountries.sort();
}

extern DT_DLL_simulationObjectEditorimpl makVrf::DtEntityMapperKey mapperKeyConversion(const DtObjectType&, int force);

inline bool operator>(const DtObjectType& lhs, const DtSimulationModelSetLoader::EntityData& rhs)
{
   return !(lhs.operator<(rhs));
}

class DT_DLL_simulationObjectEditorimpl DtSimulationObjectEditorScenarioExplorer : public DtScenarioExplorer
{
public:
   DtSimulationObjectEditorScenarioExplorer(makVrv::DtDe&, DtSimulationModelSet* baseSet, DtSimulationModelSetLoader::LoadFlags, DtSimulationModelSetLoader*);

   virtual ~DtSimulationObjectEditorScenarioExplorer();

   bool loading() const
   {
      return myLoading;
   }

   virtual void loadAllSmsFiles();

protected:
   virtual void processModelSet(DtSimulationModelSet*);

protected:
   makVrv::DtDe& myDe;
   bool myLoading = false;
   DtSimulationModelSet* mySimulationModelSet;
   DtSimulationModelSetLoader* mySimulationModelSetLoader;
   DtSimulationModelSetLoader::LoadFlags myLoadFlags;
};