DtCloudCoverManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>

#include <vrvCore/DtCloudLayer.h>
#include <vrvCore/DtRecordSettingsBackup.h>

#include <makArchives/DtCloudCoverListRecord.h>
#include <makArchives/DtCloudLayerRecord.h>
#include <makArchives/DtEnvironmentRecord.h>

#include <vrfExtObjects/vrfWeatherStateEnums.h>

#include <boost/unordered_map.hpp>
#include <vrvUtil/signalslib.h>

#include <map>

namespace makVrv
{   
   class DtDe;

   class DT_DLL_VRVCORE DtCloudCoverManager : public DtVirtualBaseClass
   {
   public:

      typedef std::list<DtCloudLayerId> CloudLayerIdList;

      struct CloudCoverData
      {
         std::string cloudCoverName;          // The name of the cloud cover
         CloudLayerIdList cloudLayerIdList;   // The cloud layer ids of all layers in the cloud cover
      };

      typedef std::map<makArchives::DtCloudCoverType, CloudCoverData> CloudCoverCloudLayerIdMap;

      static DtCloudCoverManager& instance(DtDe& de);

      virtual ~DtCloudCoverManager();

      virtual void initialize();
    

      const CloudCoverCloudLayerIdMap& cloudCoverMap() const;

      bool isValidCloudCover(makArchives::DtCloudCoverType cloudCover) const;

      bool isUserCloudCover(makArchives::DtCloudCoverType coverType) const;

      virtual std::string cloudCoverName(makArchives::DtCloudCoverType cloudCover);

      virtual makArchives::DtCloudCoverType cloudCoverType(const std::string& cloudCoverName);

      const CloudLayerIdList& cloudLayerList(makArchives::DtCloudCoverType cloudCover) const;

      bool isValidCloudLayer(DtCloudLayerId layerId) const;

      virtual makArchives::DtCloudCoverType cloudCoverForLayer(DtCloudLayerId layerId);

      virtual const DtCloudLayer& cloudLayer(DtCloudLayerId layerId) const;

      virtual bool cloudLayerEnabled(DtCloudLayerId layerId) const;


      virtual makArchives::DtCloudCoverType addCloudCover(const std::string& cloudCoverName);

      virtual void removeCloudCover(makArchives::DtCloudCoverType);

      virtual DtCloudLayerId addCloudLayer(makArchives::DtCloudCoverType cloudCover,
         const DtCloudLayer& layer );

      virtual bool deleteCloudLayer(DtCloudLayerId layerToDelete);

      virtual bool changeCloudLayer(DtCloudLayerId layerId, const DtCloudLayer& newLayer);

      virtual bool setCloudLayerPositionAndOrientation(DtCloudLayerId layerId, const DtVector& position, 
         float orientation = 0.);

      virtual bool setCloudLayerEnabled(DtCloudLayerId layerId, bool enabled );


      virtual void getRecord(makArchives::DtCloudCoverListRecord& record);

      virtual void getSplitRecord(std::vector<makArchives::DtCloudCoverListRecord>& rec,
         std::vector<std::string>& fileNames) {};

      virtual void addRecords(makArchives::DtCloudCoverListRecord& recs,
         makArchives::DtCloudCoverListRecord& combinedRec) {};

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

      virtual void slot_restored();

      virtual void saveAsDefaults();

      virtual void exportSettings(const std::string& filename);
      virtual void importSettings(const std::string& filename);

      const DtSettingsBackup* settingsBackup() const
      {
         return mySettingsBackup;
      }

      DtSettingsBackup* settingsBackup()
      {
         return mySettingsBackup;
      }

      virtual void loadDefaults(bool loadOnlyFactorySettings = false);


      boost::signal<void()> signal_cloudCoverReset;

      boost::signal<void(makArchives::DtCloudCoverType, const std::string&)> signal_cloudCoverAdded;

      boost::signal<void(makArchives::DtCloudCoverType)> signal_cloudCoverToBeRemoved;

      boost::signal<void(makArchives::DtCloudCoverType)> signal_cloudCoverRemoved;

      boost::signal<void(DtCloudLayerId, bool)> signal_cloudLayerEnabledChanged;

      boost::signal<void(DtCloudLayerId, const DtVector&, float)> signal_cloudLayerPositionAndOrientationChanged;

      boost::signal<void(DtCloudLayerId layerId, const DtCloudLayer& changedLayer)>
         signal_cloudLayerToBeModified;

      boost::signal<void(DtCloudLayerId layerId, const DtCloudLayer& oldLayer)>
         signal_cloudLayerModified;

      boost::signal<void(DtCloudLayerId newLayer, makArchives::DtCloudCoverType cover)> signal_cloudLayerAdded;

      boost::signal<void(DtCloudLayerId oldLayer)> signal_cloudLayerToBeRemoved;
   
      boost::signal<void(DtCloudLayerId oldLayer)> signal_cloudLayerRemoved;


   protected:

      DtCloudCoverManager(makVrv::DtDe&);

      virtual void autoSave();
      virtual void autoSaveDefaultsIfNeeded();

      DtCloudLayerId allocateCloudLayerId();

      makArchives::DtCloudCoverType allocateCloudCoverType();

      virtual bool getCloudCoverRecord(makArchives::DtCloudCoverType cloudCover, 
         makArchives::DtCloudCoverRecord& record) const;

      virtual void createExternalCloudCover();

   protected:

      struct LayerIdData
      {
         makArchives::DtCloudCoverType cloudCover;
         DtCloudLayer cloudLayer;
      };

      typedef boost::unordered_map<DtCloudLayerId, LayerIdData> CloudLayerIdMap;
      CloudLayerIdMap myCloudLayerIdMap;
      CloudCoverCloudLayerIdMap myCloudCoverCloudLayerIdMap;

      typedef boost::unordered_map<std::string, makArchives::DtCloudCoverType> CloudCoverNameToCloudCoverMap;
      CloudCoverNameToCloudCoverMap myCloudCoverNameToCloudCoverMap;

      DtCloudLayerId myFreeCloudLayerId;
      DtDe& myDe;
      DtRecordSettingsBackupInterface*  mySettingsBackup;
      std::vector<bool> myUserCloudTypesAvailable;
   };

   typedef DtRecordSettingsBackup<DtCloudCoverManager, makArchives::DtCloudCoverListRecord> DtCloudCoverSettingsBackup;
}