vrfVisualsManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvVrl/DtSharedSimulationSettings.h>
#include <vlpi/entityType.h>

#include <vrvVrl/DtEntityTypeMapper.h>
#include <vrfGuiCore/vrfElementDefinitionTypeManager.h>
#include <makArchives/DtElementsRecord.h>
#include <vlutil/vlFilename.h>
#include <tbb/recursive_mutex.h>

namespace makVrv
{
   class DtDe;
   class DtModelDefinitionManager;
   class DtModelDefinition;
   class DtVisualizerDefinitionSet;
   class DtVisualizerDefinition;
}

class DtSimulationModelSet;
class DtScenarioExplorer;

static tbb::recursive_mutex theVisualMutexLock;

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtVrfEntityTypeMapper : public makVrv::DtEntityTypeMapper
   {
   public:
      DtVrfEntityTypeMapper(const std::string& name)
      : makVrv::DtEntityTypeMapper(name)
      , mySharedMapper(nullptr)
      , myAutoSave(true)
      {
      }

      DtVrfEntityTypeMapper(makVrv::DtEntityTypeMapper*);

      virtual ~DtVrfEntityTypeMapper();

      void setDirectory(const DtFilename& f)
      {
         myDirectory = f;
      }

      bool autoSave() const
      {
         return myAutoSave;
      }

      bool setAutoSave(bool b)
      {
         bool autoS = myAutoSave;

         myAutoSave = b;

         return autoS;
      }

      const DtFilename& directory() const
      {
         return myDirectory;
      }

      const NameList* findMappings( const DtEntityType& type, bool exact = false ) const;

      virtual void setFromRecord(const makArchives::DtEntityTypeMappingRecord& record) override;
      virtual void setFromRecords(const makArchives::DtEntityTypeMappingRecord& record, const std::string& fileName) override;

      virtual void addMapping(const DtEntityType& type, 
         const makVrv::DtUnicode& definitionName) override;

      virtual void removeMapping(const DtEntityType& type, 
         const makVrv::DtUnicode& value) override;

      virtual void removeMappings( const DtEntityType& type ) override;
      
      virtual void mergeFromRecord(const makArchives::DtEntityTypeMappingRecord& record) override;

      bool isMappedDefinition(const makVrv::DtUnicode& def) const
      {
         return (myDefinitionsMap.find(def) != myDefinitionsMap.end());
      }

      int mappedDefinitionCount(const makVrv::DtUnicode& def) const
      {
         DefinitionsMap::const_iterator iter = myDefinitionsMap.find(def);

         if (iter != myDefinitionsMap.end())
         {
            return iter->second;
         }

         return 0;
      }

      virtual void addMappingFileLocation(const DtEntityType& type, const std::string& definitionFileName) override;

      typedef std::map<makVrv::DtUnicode,int> DefinitionsMap; 
      const DefinitionsMap& definitionsMapped() const { return myDefinitionsMap; };

      bool isSharedMapper() const
      {
         return (mySharedMapper != nullptr);
      }

      makVrv::DtEntityTypeMapper* sharedMapper() const
      {
         return mySharedMapper;
      }

   protected:
      virtual void setupDefinitionsMap();
      virtual void internalAddMapping(const DtEntityType& type, 
         const makVrv::DtUnicode& definitionName);
      virtual void internalRemoveMapping(const DtEntityType& type, 
         const makVrv::DtUnicode& definitionName);

   protected:
      DtFilename myDirectory;
      DefinitionsMap myDefinitionsMap;
      makVrv::DtSignalConnectionManager myConnections;
      makVrv::DtEntityTypeMapper* mySharedMapper;
      bool myAutoSave;
   };

   class DT_DLL_VRFGUICORE DtVrfVisualsManager : public makVrv::DtVirtualBaseClass
   {
   public:
      class Visuals;

      DtVrfVisualsManager(makVrv::DtDe&);

      virtual ~DtVrfVisualsManager();

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

      virtual bool loadVisuals(DtSimulationModelSet*, bool createIfMissing = false, bool editMode = false);

      virtual bool loadVisuals(const DtFilename&, const DtString& rootName = "");

      virtual bool createVisuals(const DtSimulationModelSet*, bool andLoad = true, 
         Visuals* visualsToUpgradeFrom = 0, const DtFilename& sourceDefinitionsDir = DtFilename::nullFilename());

      virtual bool getSystemVisualizerDefinitionAndElementTypeMap(const DtEntityType&, makVrv::DtUnicode&,
         makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes&, bool exactMatch = true);

      virtual bool isUnknown(const std::vector<makVrv::DtUnicode>& entities) const;
      virtual bool isUnknown(const makVrv::DtUnicode& entities) const;

      virtual makVrv::DtUnicode unknownString() const;

      virtual void updateUnknowns();

      const std::set<makVrv::DtUnicode> unknownStrings() const
      {
         return myUnknowns;
      }


      virtual void clear();

      virtual void setupAdditionalVisualizers();

      virtual void upgradeSpotReportsDictionary(const DtFilename& toDirectory, Visuals&, bool force = false, bool mergeAttributes = false);

      virtual bool upgradeVisuals(const DtSimulationModelSet& oldSet, const DtSimulationModelSet& newSet);

      virtual bool loadVisuals(const DtScenarioExplorer& explorer, bool createIfMissing = false, bool force = false, bool editMode = false);

      virtual const Visuals* visualsFor(const DtSimulationModelSet&) const;
      virtual Visuals* visualsFor(const DtSimulationModelSet&);
      virtual Visuals* visualsFor(const std::string&);
      virtual const Visuals* visualsFor(const std::string&) const;

      virtual makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes elementTypeFor(const DtEntityType&);

      virtual bool pruneVRFSpecificVisualizers();

      virtual bool pruneVisualizersFrom(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, const std::set<std::string>&);

      virtual void pruneFromSystemVisuals(const Visuals*);

      virtual void merge(const DtEntityType&, const Visuals*, bool toSystem = true, const DtString& newElementDefName = "", const DtEntityType& newType = DtEntityType());

      virtual void mergeElementDefinitionToSystem(const DtEntityType&);

      virtual bool saveSystemVisualsAsAppData(const DtFilename& directory, bool saveHierarchyData = true);

      virtual void createSpotReportDefinitionFor(const DtEntityType&);

      virtual bool updateAndAddMatchTypeVisuals(const DtEntityType& sourceType, const DtEntityType& matchType, bool andSystem = true);

      virtual void updateVisualsFor(const DtEntityType&);

      virtual void removeVisualsFor(const DtEntityType&, bool andSystem = true);

      virtual bool removeMappingsFor(const DtEntityType&, bool andSystem = true);

      virtual void removeElementDefinition(const DtEntityType&, bool andSystem = true);

      virtual Visuals* visualsFor(const DtEntityType&);

      virtual void setDefaultVisuals(const std::string&);
      const std::string& defaultVisuals() const;

      virtual void setCoreRootName(const std::string&);
      virtual const std::string& coreRootName() const;

      virtual void resetStartupCounts(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes);

      virtual int setDebugLevel(int);

      Visuals* systemDefaulVisuals() const { return mySystemDefaultVisuals; };

      typedef boost::unordered_map<makVrv::DtSharedSimulationSettings::MapperType, DtVrfEntityTypeMapper*> MappersMap;

      class DT_DLL_VRFGUICORE Visuals
      {
      public:
         Visuals();
         Visuals(makVrv::DtDe& de, bool inAppData, DtVrfVisualsManager* systemDefault);
         Visuals(const Visuals&);
         virtual ~Visuals();

         Visuals& operator=(const Visuals&);
         void addKeyForDefinition(const DtEntityType&, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes,
            const makVrv::DtUnicode&);

         makVrv::DtModelDefinitionManager* modelDefinitionsFrom(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes,
            const makVrv::DtUnicode&) const;
         void mergeModelDefinitions(const makVrv::DtModelDefinitionManager*);

         void initializeDefaults(const DtFilename& appDataDir = DtFilename::nullFilename());

         void initializeFrom(const DtFilename&);

         void cleanup();

         void addMapper( makVrv::DtSharedSimulationSettings::MapperType mapperType, const std::string& mapperName,
            const std::string& extension );

         void initializeMapper( makVrv::DtSharedSimulationSettings::MapperType mapperType, bool fromNewStructure = true, const DtString& definitionsDirectory = DtFilename::nullFilename() );

         bool getSystemVisualizerDefinitionAndElementTypeMap(const DtEntityType&, makVrv::DtUnicode&,
            makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes&, bool exactMatch = true);

         void modelDefinitionsFromVisualizerSet(makVrv::DtModelDefinitionManager*, const makVrv::DtVisualizerDefinitionSet&) const;

         makArchives::DtElementsRecord addLeafNodes(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, makVrv::DtElementDefinitionManager::ElementDefinitions);

         void initializeSpotReportsHierarchy(const DtFilename& directory);

         void loadOrCreateSpotReports(const DtFilename&, const DtString& root);

         bool save(const DtFilename& directory, bool spotReportsOnly);

         DtFilename setDirectoryForMapper(makVrv::DtSharedSimulationSettings::MapperType mapperType, makVrv::DtEntityTypeMapper* mapper, const DtString& definitionsDirectory);

         bool save(const DtFilename&, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, bool andSaveHierarchy = false,
            bool intoManagerSubDirectory = false, const DtFilename& definitionSubDirectory = "", bool mappedOnly = true);
         bool save(makVrv::DtElementDefinitionManager* mgr, const DtFilename& d, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes type, bool andSaveHierarchy = false,
            bool intoManagerSubDirectory = false, const DtFilename& definitionSubDirectory = "", bool mappedOnly = true);

         makVrv::DtUnicode findValidElementDefinition(const makVrv::DtEntityTypeMapper::NameList*,
            makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes) const;

         void install();

         void setDirectory(const DtFilename&);
         void setRootName(const DtString&);

         bool load(const DtFilename&, const DtString& rootName);

         bool load(const DtFilename&, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, bool andLoadHierarchy = false);

         bool installDefinitionRecordsFrom(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes);

         DtFilename modelDefinitionsPath();

         void pushMappers();
         void popMappers();

         bool loadMapFiles();

         int mappedDefinitionCount(const DtEntityType&) const;

         void removeMappings(makVrv::DtEntityTypeMapper&, const makArchives::DtEntityTypeMappingRecord&) const;

         bool upgradeSpotReportsFromDictionary(const DtFilename&, bool force = false, bool mergeAttributes = false);
         bool upgradeSpotReportsFromDictionary(const DtFilename&, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes,
            const makVrv::DtUnicode& unknownName, bool force = false, bool mergeAttributes = false, const std::string& possibleMergeName = "");

         bool addElementDefinitionToSameDictionary(const DtEntityType& sourceType, const makVrv::DtUnicode& elementDefinition, const DtString& newDefinitionName,
            bool toSystem = false);

         bool createVisualCopyOf(const DtEntityType& sourceType, const DtEntityType& destinationType, const DtString& newDefinitionName,
            bool toSystem = false);

         void mergeAttributesFrom(const makVrv::DtElementDefinitionNew* source, makVrv::DtElementDefinitionNew* spotReport,
            const std::vector<int>& supportedSets, bool mergeSymbolDecoration = false, const std::set<std::string>& ignore = std::set<std::string>());
         bool mergeItemsFrom(const makVrv::DtElementDefinitionNew* source, makVrv::DtElementDefinitionNew* spotReport,
            const std::vector<int>& supportedSets);
         void copyAttributesFrom(const makVrv::DtElementDefinitionNew* source, makVrv::DtElementDefinitionNew* spotReport,
            const std::vector<int>& supportedSets);
         
         bool spotReportHierarchyNeedsUpgrade(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes) const;

         bool isUnusedVisualizer(const makVrv::DtVisualizerDefinition* visDef) const;

         bool isMappedDefinition(const makVrv::DtUnicode&);

         bool isMappedDefinition(const makVrv::DtUnicode&, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes);

         void leafNodes(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, makArchives::DtElementsRecord&,
            makArchives::DtElementsRecord* recHierRet = 0);

         bool needsLoading() const;
         bool needsLoading(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes) const;

         bool updateAndAddMatchTypeVisuals(const DtEntityType& sourceType, const DtEntityType& matchType, bool andSystem = true);

         DtFilename mapperDirectory(const DtFilename& root, makVrv::DtSharedSimulationSettings::MapperType type) const;

         DtFilename elementDefinitionDirectory(const DtFilename& root, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes type) const;

         std::set<std::string> hierarchyElementsForVisuals();

         std::set<std::string> systemHierarchyElementsForVisuals(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes);

         void getAllLeavesThatAreNotHierarchyItems(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, makArchives::DtElementsRecord&,
            bool haveMappings = false);

         void merge(const Visuals*);

         void merge(const DtEntityType&, const Visuals*, bool toSystem = true, const DtString& newElementDefName = "", const DtEntityType& newType = DtEntityType());

         void mergeElementDefinitionToSystem(const DtEntityType&);

         virtual bool saveAsAppData(const DtFilename& definitionsDirectory, bool saveHierarchyData = true);

         bool installDefinitionRecordsFrom(makVrv::DtElementDefinitionManager* thisMgr,
            makVrv::DtElementDefinitionManager* thatMgr);

         void installHierarchyInto(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes from,
            makArchives::DtElementsRecord& spoReportHierarchy);

         bool prune(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes,
            const Visuals* source);
         void merge(makVrv::DtSharedSimulationSettings::MapperType, const Visuals*);

         void prune(makVrv::DtSharedSimulationSettings::MapperType, const Visuals*);

         void saveMappersTo(const DtFilename&);
         void saveMapper(const DtFilename& directory, int mapperType, const makVrv::DtEntityTypeMapper& mapper);
         void addMappingFileLocation(makVrv::DtSharedSimulationSettings::MapperType mapperType, const DtEntityType& from, bool useDefault = false,
            const DtString& name = "");

         void prune(const Visuals*);
         void saveVisualElementsFor(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes type, bool saveHierarchy = false);

         void saveModelDefinitions();

         void changeMappingType(const DtEntityType& from, const DtEntityType& to, bool toSystem = true, bool removeOld = true);

         void associateMappingTypes(const DtEntityType& from, const DtEntityType& to, bool toSystem = true);

         void removeSymbolDecorationAttribute(makVrv::DtElementDefinitionNew*, const std::vector<int>& supportedSets);
         void addSymbolDecorationAttribute(makVrv::DtElementDefinitionNew*, const std::vector<int>& supportedSets);

         void saveMapper(const DtFilename&, makVrv::DtSharedSimulationSettings::MapperType);

         makVrv::DtSharedSimulationSettings::MapperType mapElementTypeToMapperType(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes) const;
         makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes mapMapperTypeToElementType(makVrv::DtSharedSimulationSettings::MapperType) const;

         void install(const DtEntityType&, bool mapOnly = false);

         void createSpotReportDefinitionFor(const DtEntityType&);

         void upgradeElementsForDefinition(const makVrv::DtUnicode& defs, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes);

         void removeVisualsFor(const DtEntityType&, bool fromSystem = true);

         bool removeMappingsFor(const DtEntityType&, bool andSystem = true);

         void updateElementDefinitions(makArchives::DtElementsRecord& destination, const makArchives::DtElementsRecord& source, const std::string& prepend);

         void removeElementDefinition(const DtEntityType&, bool fromSystem = true);
         void removeElementsForDefinition(const makVrv::DtUnicode& defs, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes,
            bool fromSystem = true);

         bool loadMapper(makVrv::DtSharedSimulationSettings::MapperType mapperType, makVrv::DtEntityTypeMapper* mapper, const DtString& definitionsDirectory);

         DtVrfEntityTypeMapper* mapper(makVrv::DtSharedSimulationSettings::MapperType mapperType) const;

         bool hasType(const DtEntityType&) const;

         makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes elementTypeFor(const DtEntityType&) const;

         const makVrv::DtEntityTypeMapper::NameList* definitionsMapped(const DtEntityType&, makVrv::DtSharedSimulationSettings::MapperType&);
         makVrv::DtSharedSimulationSettings::MapperType mapperTypeFor(const DtEntityType&) const;

         DtFilename rootDirectoryForManager(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes mapper) const;
         virtual bool containsUnknown(const makVrv::DtEntityTypeMapper::NameList* names) const;

         typedef std::map<makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, int> LastWriteTimes;
         LastWriteTimes myLastWriteTimes;

         DtVrfElementDefinitionTypeManager* elementDefinitionManager;
         MappersMap mappers;
         std::vector<MappersMap> pushedMappers;
         makVrv::DtDe* myDe;
         DtFilename myDirectory;
         DtString myRootName;
         bool myInAppData;
         DtVrfVisualsManager* myVisualsManager;
      };

      virtual bool setupBoundingVolumes();

      virtual void initializeSystemVisuals(const DtFilename& definitionsDir = DtFilename::nullFilename(),bool setupSpotReports = true);

      boost::signals2::signal<void ()> signal_visualsLoaded;
      boost::signals2::signal<void (const DtFilename&)> signal_visualsLoadedFrom;
      boost::signals2::signal<void (DtSimulationModelSet*)> signal_spotReportVisualsLoadedFromSMS;
      boost::signals2::signal<void (DtSimulationModelSet*)> signal_visualsLoadedFromSMS;

   protected:

      virtual void setupObjectConsoleWarningVisualizer();

      virtual bool pruneVisualizersFrom(makVrv::DtElementDefinitionNew*, const std::set<std::string>&);

      virtual void setupAdditionalTacticalGraphicsVisualizers();      

      virtual void setupCloudLayers();
      virtual void setupCloudDisplayLayer(const std::string&, const DtEntityType&, int r, int g, int b, int a);

      virtual void setupNavigationAreaVisualizer();      

      virtual void setupObjectConsoleWarngForTacticalGraphics();

      virtual bool setupBoundingVolumes(const std::string& root);

      virtual void setupObjectConsoleWarningVisualizer(const std::string& root);

      virtual void setupAdditionalSpotReportVisualizers();

      virtual void setupAdditionalSpotReportVisualizers(const makVrv::DtUnicode&);

      virtual void setupRangeRings();
      virtual void addRangeRingsFor(int managerType);

      virtual void setupSensorContactLines();
      virtual void addSensorContactLinesFor(int managerType);

      virtual void setupAdditionalAggregateVisualizers();

   protected:
      makVrv::DtDe& myDe;

      Visuals* mySystemDefaultVisuals;

      struct ModelSetVisual
      {
         ModelSetVisual() {};
         ModelSetVisual(const DtFilename& f, const Visuals& v) : filename(f), visuals(v) {};
         ModelSetVisual(const ModelSetVisual& orig) : filename(orig.filename), visuals(orig.visuals) {};
         ModelSetVisual& operator=(const ModelSetVisual& orig) { filename = orig.filename; visuals = orig.visuals; return *this; };

         DtFilename filename;
         Visuals visuals;
      };

      typedef std::vector<ModelSetVisual> SimulationModelSetVisuals;
      SimulationModelSetVisuals mySimulationModelSetVisuals;

      std::string myDefaultVisuals;      
      std::string myCoreRootName;

      std::set<DtFilename> mySystemVisuals;

      std::set<makVrv::DtUnicode> myUnknowns;
   };
}