DtElementDefinitionManager.h

Go to the documentation of this file.

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

#pragma once
#include <boost/unordered_map.hpp>
#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtVisualizerAttribute.h>
#include <vrvCore/DtElementDefinitionSettings.h>
#include <vrvCore/DtRecordSettingsBackup.h>
#include <vrvCore/DtVisualizerDefinitionValidator.h>

#include <makArchives/DtElementsRecord.h>

#include <boost/signal.hpp>

namespace makArchives
{
   class DtElementDefinitionRecord;
   class DtElementsRecord;

   namespace oldRecords
   {
      class DtElementDefinition;
      class DtElementDefinitionHierarchy;
      class DtElementDefinitionNode;
      class DtVisualAttributeInterface;
   };
}

namespace makVrv
{
   class DtDe;
   class DtBaseConnection;
   class DtElementDefinitionNew;
   class DtDeSettings;

   class DT_DLL_VRVCORE DtElementDefinitionManager
   {
   public:
      typedef std::map<DtUnicode, DtElementDefinitionNew*>
            DefinitionMap;

      typedef std::vector<const DtElementDefinitionNew*> ElementDefinitions;

      static const DtElementDefinitionManager* createConstCopy(
         const DtElementDefinitionManager& orig);

      virtual ~DtElementDefinitionManager();

      const std::string& name() const;

      const DtUnicode& screenName() const;

      unsigned int numberOfElementDefinitions() const;

      const DefinitionMap& elementDefinitions() const;

      DtElementDefinitionNew* findElementDefinition(
         const DtUnicode& definitionName);

      const DtElementDefinitionNew* findElementDefinition(
         const DtUnicode& definitionName) const;

      DtElementDefinitionNew* createElementDefinition(
         const DtUnicode& definitionName);
      
      DtElementDefinitionNew* createElementDefinition( 
         const DtUnicode& definitionName, 
         DtElementDefinitionNew* parentDefinition);

      void destroyElementDefinition(DtElementDefinitionNew*);

      void destroyElementDefinitionAndChildren(DtElementDefinitionNew*);

      DtElementDefinitionNew* copyElementDefinition(DtElementDefinitionNew& def,
         const DtUnicode& newName);

      DtBackupInterface* backup();

      bool renameElementDefinition(const DtUnicode& oldName, 
         const DtUnicode& newName);

      void loadDefaults();

      void loadDefaults(bool loadOnlyFactory);

      void revertSettings();

      virtual void saveAsDefaults();

      virtual void exportSettings(const std::string& fileName);

      virtual void importSettings(const std::string& fileName,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void importSettings(const std::string& fileName);

      virtual void mergeSettings(const std::string& fileName,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual DtDeSettings* settings();

      virtual void setFromRecord(const makArchives::DtElementsRecord& rec);

      virtual void setFromRecord(const makArchives::DtElementsRecord& rec,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void mergeRecord(
         const makArchives::DtElementsRecord& rec,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void getRecord(makArchives::DtElementsRecord& rec);

      virtual void setAutoSave(bool enabled);

      virtual bool validateElementDefinition(const DtElementDefinitionNew& def);

   protected:

      friend class DtElementDefinitionTypeManager;

      DtElementDefinitionManager(const std::string& name, 
         const DtUnicode& screenName, DtDe& de, bool procedural);

      DtElementDefinitionManager(const DtElementDefinitionManager& rhs);

      void registerDefinitionHierarchy(DtElementDefinitionNew* root);

      static DtVisualizerAttribute* attributeFromOldRecord(
         const makArchives::oldRecords::DtVisualAttributeInterface* attributeRecord);

      void setFromOldRecord(
         const makArchives::oldRecords::DtElementDefinitionHierarchy& oldRe,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      void loadOldDefinitionNode(DtElementDefinitionNew* parent,
         const makArchives::oldRecords::DtElementDefinitionNode& oldDef,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      void buildDefinitionSetsFromOldRecord(DtElementDefinitionNew& newElem, 
         const makArchives::oldRecords::DtElementDefinition& oldElem);

      typedef std::vector<const makArchives::DtElementDefinitionRecord*> ElementGroup;

      typedef std::map<DtUnicode, ElementGroup> ParentToElementsMap;

      virtual void buildElementVisualizers(DtElementDefinitionNew& ed,
         const makArchives::DtElementDefinitionRecord& rec);

      virtual void buildElementChildren(
         DtElementDefinitionNew& ed, ParentToElementsMap& parentToElementsMap,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      static makArchives::DtElementDefinitionRecord
         buildElementDefinitionRecord( DtElementDefinitionNew& elementDef);

      virtual void registerBackup();

      virtual bool recordMatchesDefinition(
         const makArchives::DtElementDefinitionRecord* childRec,
         const DtElementDefinitionNew* existingChildDef) const;
   private:
      DtElementDefinitionManager();

      DtElementDefinitionManager& operator=( const DtElementDefinitionManager& );

   protected:
      typedef std::map<std::string, DtVisualizerDefinitionValidator*> VisualizerDefinitionValidatorMap;
      typedef DtRecordSettingsBackup<DtElementDefinitionManager, makArchives::DtElementsRecord>
         ElementDefinitionsBackup;

      VisualizerDefinitionValidatorMap myValidators;

      std::string myName;
      DtUnicode myScreenName;

      DtDe* myOptionalDe;
      DefinitionMap myDefinitions;
      bool myProceduralFlag;
      bool myAutoSave;

      ElementDefinitionsBackup* myBackup;
   };


   class DT_DLL_VRVCORE DtElementDefinitionTypeManager :
      public DtVirtualBaseClass
   {
   public:

      typedef unsigned int ElementDefinitionType;

      enum BuiltInElementTypes
      {
         Entity,
         TacticalGraphics,
         Interaction,
         Aggregate,                
         Intervisibility,
         TacticalSmoke,
         BuiltInElementTypes_End,
      };

      static DtElementDefinitionTypeManager& instance(DtDe& de);

      static DtElementDefinitionTypeManager& instance(DtBaseConnection& con);

      static void copyInstance(DtBaseConnection& con, DtDe&);

      static const DtElementDefinitionTypeManager* createConstCopy(DtDe& de);

      virtual ~DtElementDefinitionTypeManager();

      void registerElementType(ElementDefinitionType type,
         const std::string& name, const DtUnicode& typeScreenName, 
         bool proceduralOnly);

      DtElementDefinitionManager* findElementManager(ElementDefinitionType type);

      DtElementDefinitionManager& elementManager(ElementDefinitionType type);

      const DtElementDefinitionManager& elementManager(
         ElementDefinitionType type) const;

      void loadDefaults();

   protected:

      template <typename ManagerClass>
      friend ManagerClass& defaultManagerInstanceFunction(DtDe&,bool);

      template <typename ManagerClass>
      friend void defaultManagerRegisterInstanceFunction(DtDe&, ManagerClass*);

      DtElementDefinitionTypeManager();

      DtElementDefinitionTypeManager(DtDe&);

      DtElementDefinitionTypeManager(const DtElementDefinitionTypeManager&);

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

   protected:

      typedef boost::unordered_map<unsigned int, DtElementDefinitionManager*>
         ManagerMap;

      DtDe* myOptionalDe;
      DtSignalConnectionManager myConnections;
      ManagerMap myManagers;
   };


   class DT_DLL_VRVCORE DtElementDefinitionSignaler : public DtVirtualBaseClass
   {
   public:
      static DtElementDefinitionSignaler& instance(DtDe&);

      virtual ~DtElementDefinitionSignaler();

      //Signals.
      boost::signal<void (const DtUnicode& oldName, const DtUnicode& newName)>
         signal_elementRenamed;

   protected:
      DtElementDefinitionSignaler();

   private:
      DtElementDefinitionSignaler( const DtElementDefinitionSignaler& );

      DtElementDefinitionSignaler& operator=( const DtElementDefinitionSignaler& );

   };
}