DtDeInitializer.h

Go to the documentation of this file.

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


#pragma once

#include <vrvUtil/vrvUtil.h>
#include <vrvUtil/DtConfiguration.h>
#include <vrvUtil/DtDebugLog.h>
#include <vrvUtil/DtDeConfiguration.h>
#include <vrvUtil/DtDriverConfiguration.h>
#include <vrvUtil/DtGuiConfiguration.h>
#include <vrvUtil/DtDePathConfiguration.h>
#include <vrvUtil/DtInputDriverConfiguration.h>
#include <vrvUtil/DtRecordHolder.h>

#include <makArchives/DtObserverStateRecord.h>
#include <makArchives/DtSerialize.h>

#include <vector>

namespace makVrv
{

   class DtBaseRecordHolder;

   class DT_DLL_VRVUTIL DtDeInitializer : public DtConfiguration
   {
   public:

      enum DeMode
      {
         NoMode     = 0,
         MasterMode = 1,
         SlaveMode  = 2,
         DeMode_end  

      };

      enum DeFeatures
      {
         Features_None = 0,
         Features_2D   = 1,
         Features_3D   = 2,
         Features_Stealth = Features_3D | Features_2D,
         DeFeatures_end
      };


      typedef std::vector<std::pair<std::string,DtConfiguration> >
         DriverInstanceList;

      typedef std::map<std::string, std::string> AuthorizationCodeMap;

      typedef std::vector<std::pair<std::string, makArchives::DtObserverStateRecord> >
         ObserverStateMap;

      typedef std::map<std::string,DtBaseRecordHolder*> DefaultRecordMap;

      struct DisplayConnection
      {
         int port;
         std::string address;
         DtDisplayConfiguration configuration;

         template<class Archive>
            void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(port);
            ar & BOOST_SERIALIZATION_NVP(address);
            ar & BOOST_SERIALIZATION_NVP(configuration);
         }
      };

      typedef std::vector<DisplayConnection> DisplayConnections;

   public:

      DtDeInitializer( const std::string& name = "" );

      DtDeInitializer( const DtDeInitializer& initializer );

      DtDeInitializer& operator = ( const DtDeInitializer& initializer );

      virtual ~DtDeInitializer();

      void setFeatures( DeFeatures features );

      DeFeatures features() const;

      bool featureSupported( DeFeatures feature ) const;

      DT_DECLARE_serialize_FUNCTIONS

      const DtDriverConfiguration& driverConfiguration() const;
      DtDriverConfiguration& driverConfiguration();

      void setDriverConfiguration(const DtDriverConfiguration&);

      const DtGuiConfiguration& guiConfiguration() const;
      DtGuiConfiguration& guiConfiguration();

      void setGuiConfiguration( const DtGuiConfiguration& config );

      const DtInputDriverConfiguration& inputDriverConfiguration() const;
      DtInputDriverConfiguration& inputDriverConfiguration();

      void setInputDriverConfiguration( const DtInputDriverConfiguration& config );

      const std::string& displayName() const;

      void setDisplayEngineName( const std::string& name );

      DtDeInitializer::DeMode deMode() const;

      void setDeMode( DtDeInitializer::DeMode mode );

      void setDefaultDrivers( const DriverInstanceList& drivers );

      const DriverInstanceList& defaultDrivers() const;

      void setDeConfiguration( const DtDeConfiguration& config );

      DtDeConfiguration& deConfiguration();

      const DtDeConfiguration& deConfiguration() const;

      void setCoordinateSystem( const std::string& coordinateSystem,
         const std::string& parameters );

      const std::string& coordinateSystem() const;

      const std::string& coordinateSystemParameters() const;

      void setNotifyLevel( DtDebugLog::PrintLevel level );

      DtDebugLog::PrintLevel notifyLevel() const;

      void setLogFileName( const std::string& filename );

      const std::string& logFileName() const;

      void setAutoLoadDrivers( bool autoLoad );

      bool autoLoadDrivers() const;

      void setAutoStartDrivers( const std::vector<std::string>& names );

      const std::vector<std::string>& autoStartDrivers() const;

      void setAuthorizationCodeMap( const AuthorizationCodeMap& map );

      void addAuthorizationCodeMapping( const std::string& key,
         const std::string& value );

      void removeAuthorizationCodeMapping( const std::string& key );

      const std::string* findAuthorizationCodeValue( const std::string& key ) const;

      void setObserverStateMap( const ObserverStateMap& osm );

      const ObserverStateMap& observerStateMap() const;

      const std::vector<std::string>& mappingFilesToLoad() const;

      void setMappingFilesToLoad( const std::vector<std::string>& );

      const DisplayConnections& displayConnections() const;
      DisplayConnections& displayConnections();

      void setDisplayConnections( const DisplayConnections& displayConnections );

      void setAutoLoadFile( const std::string& file );

      const std::string& autoLoadFile() const;

      void setStartFullScreen( bool );

      bool startFullScreen() const;

      void addDefaultSettingsRecord( const std::string& recordName,
         const DtBaseRecordHolder& record );

      void removeDefaultSettingsRecord( const std::string& record );

      template <typename RecordType>
      bool findDefaultSettingsRecord( const std::string& name, RecordType& record ) const
      {
         DefaultRecordMap::const_iterator iter = myDefaultRecords.find( name );
         if ( iter != myDefaultRecords.end() )
         {
            const DtRecordHolder<RecordType>* holder =
               dynamic_cast<const DtRecordHolder<RecordType>*>( iter->second );
            if ( holder )
            {
               record = holder->record();
               return true;
            }
         }

         return false;
      }

      void setConstrainToTerrain( bool constrain );
      bool constrainToTerrain() const;

      void setSpeedScaling( bool scale );
      bool speedScaling() const;
      
      void setVertexSelectsParent( bool selectsParent );
      bool vertexSelectsParent() const;

      void setDoubleBuffering( bool buffer );
      bool doubleBuffer() const;

      void setVSync( bool sync );
      bool vsync() const;

      void setFixedFrameRate( unsigned int framesPerSecond );
      unsigned int fixedFrameRate() const;

      void setPathConfiguration( const DtDePathConfiguration& pathConfig );

      DtDePathConfiguration& pathConfiguration();

      const DtDePathConfiguration& pathConfiguration() const;

      void setInitLibXml( bool enabled );

      bool initLibXml() const;

      void setCheckForData( bool check );

      bool checkForData() const;

   protected:

      template<class Archive>
         void _serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_BASE(DtConfiguration);
         ar & DT_SERIALIZE_MEMBER(myDriverConfiguration);
         ar & DT_SERIALIZE_MEMBER(myGuiConfiguration);
         ar & DT_SERIALIZE_MEMBER(myInputDriverConfiguration);
         ar & DT_SERIALIZE_MEMBER(myDisplayEngineName);

         ar & DT_SERIALIZE_MEMBER(myDeMode);
         ar & DT_SERIALIZE_MEMBER(myDriverInstances);
         ar & DT_SERIALIZE_MEMBER(myCoordinateSystem);
         ar & DT_SERIALIZE_MEMBER(myCoordinateSystemParameters);

         ar & DT_SERIALIZE_MEMBER(myDeConfiguration);

         ar & DT_SERIALIZE_MEMBER(myAutoLoadDriversFlag);

         ar & DT_SERIALIZE_MEMBER(myAutoStartDrivers);
         ar & DT_SERIALIZE_MEMBER(myMappingFilesToLoad);

         ar & DT_SERIALIZE_MEMBER(myDisplayConnections);
         ar & DT_SERIALIZE_MEMBER(myAutoLoadFile);
         ar & DT_SERIALIZE_MEMBER(myFullScreenFlag);
         ar & DT_SERIALIZE_MEMBER(myConstrainToTerrainFlag);
         ar & DT_SERIALIZE_MEMBER(mySpeedScalingFlag);

         ar & DT_SERIALIZE_MEMBER(myDoubleBufferFlag);
         ar & DT_SERIALIZE_MEMBER(myVSyncFlag);

         ar & DT_SERIALIZE_MEMBER(myDefaultRecords);

         if (version >= 2)
         {
            ar & BOOST_SERIALIZATION_NVP(myInitLibXml);
         }
         if(version >= 3)
         {
            ar & BOOST_SERIALIZATION_NVP(myFeatures);
         }
         if(version >= 4)
         {
            ar & BOOST_SERIALIZATION_NVP(myVertexSelectsParentFlag);
         }

         if(version >= 5)
         {
            ar & BOOST_SERIALIZATION_NVP(myCheckForData);
         }
      }

   protected:

      DtDriverConfiguration myDriverConfiguration;
      DtGuiConfiguration myGuiConfiguration;
      DtInputDriverConfiguration myInputDriverConfiguration;
      std::string myDisplayEngineName;

      DtDePathConfiguration myPathConfiguration;
      DtDeConfiguration myDeConfiguration;

      DeMode myDeMode;
      DriverInstanceList myDriverInstances;
      std::string myCoordinateSystem;
      std::string myCoordinateSystemParameters;
      int myNotifyLevel;
      std::string myLogFileName;

      bool myAutoLoadDriversFlag;

      AuthorizationCodeMap myAuthorizationCodeMap;

      std::vector<std::string> myAutoStartDrivers;
      ObserverStateMap myObserverStateMap;
      std::vector<std::string> myMappingFilesToLoad;

      DisplayConnections myDisplayConnections;
      std::string myAutoLoadFile;

      bool myFullScreenFlag;
      bool myConstrainToTerrainFlag;
      bool mySpeedScalingFlag;
      bool myVertexSelectsParentFlag;

      bool myDoubleBufferFlag;
      bool myVSyncFlag;
      unsigned int myFrameRate;
      bool myInitLibXml;
      bool myCheckForData;

      DefaultRecordMap myDefaultRecords;

      DeFeatures myFeatures;

   };

}

BOOST_CLASS_VERSION( makVrv::DtDeInitializer, 5 )