vrfSessionSettingsRecord.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrvUtil/DtUnicode.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtVrfSessionSettingsRecord
   {
   public:
      enum VrfSessionSettingsOptions
      {
         DtAutoJoinSession                =  0x00000001,
         DtAskToJoin                      =  0x00000002,
         DtAlwaysJoinWithSessionDatabase  =  0x00000004,
         DtAlwaysJoinWithOpenDatabase     =  0x00000008,
         DtShowSessionDialogs             =  0x00000010,
         DtDisplayCorrelationWarningMessages =  0x00000020,
         DtShowSessionStartupDialog       = 0x00000040,
         DtStartOnNewVRTheWorld           = 0x00000080,
         DtStartOnNewScenario           = 0x00000100,
         DtStartOnLoadScenario           = 0x00000200,
         DtAggregateOnCreate             = 0x00000400,
         DtUserDefinedSmoothing             = 0x00000800,
         DtShowScenarioDescriptionDialog    = 0x00001000,
         DtZoomToScenarioExtentsOnLoad    = 0x00002000,
         DtUseAdditionalWindowTitle    = 0x00004000,
         DtUseSimulationTimeForAdvancement    = 0x00008000,
         DtShowOverlayBar              = 0x00010000,
         DtSetScenarioStartTimeAtDefault              = 0x00020000,
         DtAutomaticallyOpenSessionDatabaseWithoutJoiningSession                =  0x00040000,
         DtUseStartFreezePdus       = 0x00080000,
      };

      struct SimulationModelSetConfiguration
      {
         std::string title;
         std::vector<std::string> simulationModelSets;
         std::string additionalInformation;
         friend class boost::serialization::access;

         template<class Archive>
            void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(title);
            ar & BOOST_SERIALIZATION_NVP(simulationModelSets);
            ar & BOOST_SERIALIZATION_NVP(additionalInformation);
         }
      };

   public:
      DtVrfSessionSettingsRecord();
      DtVrfSessionSettingsRecord(const DtVrfSessionSettingsRecord& orig);

      virtual ~DtVrfSessionSettingsRecord();

   public:

      virtual void setFlag(int flag, bool set);

      void setAutoJoinSession(bool);
      bool autoJoinSession() const;

      void setAutomaticallyOpenSessionDatabaseWithoutJoiningSession(bool);
      bool automaticallyOpenSessionDatabaseWithoutJoiningSession() const;

      void setAskToJoin(bool);
      bool askToJoin() const;

      void setAlwaysJoinWithSessionDatabase(bool);
      bool alwaysJoinWithSessionDatabase() const;

      void setAlwaysJoinWithOpenDatabase(bool);
      bool alwaysJoinWithOpenDatabase() const;

      virtual void setUseStartFreezePdus(bool);
      virtual bool useStartFreezePdus() const;

      void setDisplaySessionDialogs(bool);
      bool displaySessionDialogs() const;

      void setZoomToScenarioExtentsOnLoad(bool);
      bool zoomToScenarioExtentsOnLoad() const;

      void setDisplayCorrelationWarningMessages(bool);
      bool displayCorrelationWarningMessages() const;

      void setShowSessionStartupDialog(bool);
      bool showSessionStartupDialog() const;

      void setStartupPreference(int);
      int startupPreference() const;

      void setAggregateOnCreate(bool);
      bool aggregateOnCreate() const;

      virtual void setUseSimulationTimeForAdvancement(bool);
      virtual bool useSimulationTimeForAdvancement() const;

      virtual void setShowOverlayBar(bool);
      virtual bool showOverlayBar() const;

      void setShowScenarioDescriptionDialog(bool);
      bool showScenarioDescriptionDialog() const;

      void setUserDefinedSmoothing(bool);
      bool userDefinedSmoothing() const;

      virtual void setTimeScaleRange(double low, double high);
      virtual void getTimeScaleRange(double& low, double& high) const;

      void setHelpFile(const std::string&);
      const std::string& helpFile() const;

      void setDefaultScenarioFile(const std::string&);
      const std::string& defaultScenarioFile() const;

      void setDefaultSimulationModelSetFile(const std::string&);
      const std::string& defaultSimulationModelSetFile() const;

      virtual void setUseAdditionalWindowTitle(bool);
      virtual bool useAdditionalWindowTitle() const;

      virtual void setAdditionalWindowTitle(const makVrv::DtUnicode&);
      virtual makVrv::DtUnicode additionalWindowTitle() const;

      virtual const std::vector<SimulationModelSetConfiguration>& simulationModelSetConfigurations() const;
      virtual void setSimulationModelSetConfigurations(const std::vector<SimulationModelSetConfiguration>&);

      virtual void setScenarioStartTimeAtDefault(bool);
      virtual bool scenarioStartTimeAtDefault() const;

      virtual void setDefaultScenarioStartTime(time_t);
      virtual time_t defaultScenarioStartTime() const;

   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(mySessionOptions);

         if ((version == 1) && (Archive::is_loading::value))
         {
            setFlag(DtShowSessionStartupDialog, true);
         }
         else if ((version == 2) && (Archive::is_loading::value))
         {
            myHelpFile = "../doc/help/vr-forces_help.qhc";
         }
         else if (version >= 4)
         {
            ar & BOOST_SERIALIZATION_NVP(myHelpFile);
            ar & BOOST_SERIALIZATION_NVP(myDefaultScenarioFile);
            ar & BOOST_SERIALIZATION_NVP(myDefaultSimulationModelSetFile);

            if ((version <= 4) && (Archive::is_loading::value))
            {
               setFlag(DtUseAdditionalWindowTitle, false);
            }

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

               if (version >= 6)
               {
                  ar & BOOST_SERIALIZATION_NVP(mySimulationModelSetConfigurations);

                  if (version >= 7)
                  {
                     ar & BOOST_SERIALIZATION_NVP(myTimescaleLow);
                     ar & BOOST_SERIALIZATION_NVP(myTimescaleHigh);

                     if (version >= 10)
                     {
                        ar & BOOST_SERIALIZATION_NVP(myDefaultScenarioStartTime);
                     }
                  }
               }
            }
         }

         if (Archive::is_loading::value && (version <= 8))
         {
            setFlag(DtUseSimulationTimeForAdvancement, true);
            setFlag(DtShowOverlayBar, true);
         }
      }

   protected:
      VrfSessionSettingsOptions   mySessionOptions;
      std::string myHelpFile;
      std::string myDefaultScenarioFile;
      std::string myDefaultSimulationModelSetFile;
      std::string myAdditionalWindowTitle;
      std::vector<SimulationModelSetConfiguration> mySimulationModelSetConfigurations;
      double myTimescaleLow;
      double myTimescaleHigh;
      time_t myDefaultScenarioStartTime;
   };
}

BOOST_CLASS_VERSION(makVrf::DtVrfSessionSettingsRecord,10)