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/signalslib.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvVrl/DtSharedSimulationSettings.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::DtSharedSimulationSettings::MapperType t)
      : makVrv::DtEntityTypeMapper(name)
      , myMapperType(t)
      {
      }

      virtual ~DtVrfEntityTypeMapper();

      void setFilename(const DtFilename& f)
      {
         myFilename = f;
      }

      const DtFilename& filename() const
      {
         return myFilename;
      }

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

      virtual void setFromRecord(const makArchives::DtEntityTypeMappingRecord& record);

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

      virtual void removeMapping(const DtEntityType& type, 
         const makVrv::DtUnicode& value);
      
      virtual void mergeFromRecord(const makArchives::DtEntityTypeMappingRecord& record);
      
      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;
      }

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

      virtual void mergeTypeMappingsFromPath(makVrv::DtDe&, const std::string& path);

   protected:
      virtual void setupDefinitionsMap();

   protected:
      DtFilename myFilename;
      DefinitionsMap myDefinitionsMap;
      makVrv::DtSharedSimulationSettings::MapperType myMapperType;
   };

   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 clearSimulationModelSetVisuals();

      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 void mergeVisualsIntoSystemVisuals(const Visuals*);

      virtual void pruneFromSystemVisuals(const Visuals*);

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

      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);

      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 useNewStructure, bool inAppData);
         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 pruneModelDefinitions(const makVrv::DtModelDefinitionManager*);

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

         void initializeFrom(const DtFilename&, bool useNewStructure);

         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);

         bool save(const DtFilename& directory);

         bool save(const DtFilename&, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes, 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 useManagerSubStructure = false);

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

         void loadOrCreateSpotReports(const DtFilename&, const DtString& root, bool install = true);

         void pushMappers();
         void popMappers();

         bool loadMapFiles();

         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 initializeSpotReportsHierarchy();

         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 modelDefinitionsPath(const DtFilename& root) const;

         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 = "");

         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&, bool useNewDirectoryStructure = false);

         void prune(const Visuals*);

         void saveVisualElementsFor(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes type);

         void saveModelDefinitions();

         void changeMappingType(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&);

         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 hasType(const DtEntityType&) const;

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

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

         DtFilename rootDirectoryForMapper(makVrv::DtSharedSimulationSettings::MapperType mapper) 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;

         void setLoadAllModelDefinitions(bool b) { myLoadAllModelDefinitions = b; };
         bool loadAllModelDefinitions() const { return myLoadAllModelDefinitions; };

         DtVrfElementDefinitionTypeManager* elementDefinitionManager;
         makVrv::DtModelDefinitionManager* modelDefinitions;
         MappersMap mappers;
         std::vector<MappersMap> pushedMappers;
         makVrv::DtDe* myDe;
         DtFilename myDirectory;
         DtString myRootName;
         bool myUseNewSystemDataStructure;
         bool myLoadAllModelDefinitions;
         bool myInAppData;
      };


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

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

   protected:

      virtual void setupAdditionalTacticalGraphicsVisualizers();      

      virtual void setupNavigationAreaVisualizer();      

      virtual void setupBoundingVolumes();

      virtual void setupObjectConsoleWarngForTacticalGraphics();

      virtual void setupBoundingVolumes(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;
      bool myUseNewSystemDataStructure;

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

      std::set<DtFilename> mySystemVisuals;

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