radarCoverageManager.h

Go to the documentation of this file.

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



#pragma once


#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/radarCoverageSettingsRecord.h>
#include <vrfGuiCore/vrfExtendedIntervisibilitySettings.h>
#include <vrfutil/rwUUID.h>
#include <vrfutil/radarCoverageAltitudeSettings.h>

#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtEntityState.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtSharedSettings.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/event_signal.h>

namespace makVrv
{
   class DtDe;
   class DtRecordSettingsBackupInterface;
   class DtSimObjectEntry;
   class DtIntervisibilityElement;
}

class DtUUID;
class DtSimMessage;
class DtIfRadarCoverageInformationResponse;

namespace makVrf
{
   class DtVrfBackendState;
   class DtIntervisibilitySensorFanStateListener;
   class DtIntervisibilitySensorFanVisualizer;

   class DT_DLL_VRFGUICORE DtRadarCoverageManager : public makVrv::DtVirtualBaseClass
   {
   public:
      typedef std::map<double, DtVrfExtendedIntervisibilitySettingsData::Color> ColorMap;

      DtRadarCoverageManager(makVrv::DtDe&);
      virtual ~DtRadarCoverageManager();

      static DtRadarCoverageManager& instance(makVrv::DtDe& de);

   public:
      virtual void startMonitoring(const DtUUID&);

      virtual bool stopMonitoring(const DtUUID&, bool signal = true, bool beingRemoved = false);

      bool monitoring(const DtUUID& uuid) const
      {
         return (myMonitoring.find(uuid) != myMonitoring.end());
      }

      virtual void loadDefaults(bool fromFactory = false);

      virtual void saveAsDefaults();

      const makVrv::DtRecordSettingsBackupInterface* settingsBackup() const
      {
         return mySettingsBackup;
      }

      makVrv::DtRecordSettingsBackupInterface* settingsBackup()
      {
         return mySettingsBackup;
      }

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

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

      void setAutoSave(bool b);
      bool autoSave() const;

      virtual void getRecord(DtRadarCoverageSettingsRecord& rec) const;
      virtual void setFromRecord(const DtRadarCoverageSettingsRecord& rec);

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

      virtual void addRecords(DtRadarCoverageSettingsRecord& recs,
         DtRadarCoverageSettingsRecord& combinedRec) {};

      virtual void setAlpha(double d);
      virtual double alpha() const;

      virtual void setWaitingForServerColor(unsigned int);
      virtual unsigned int waitingForServerColor() const;
      virtual void waitingForServerColorOSG(float& r, float& g, float& b, float& a) const;

      virtual void setAltitudeMSL(bool);
      virtual bool altitudeMSL() const;

      virtual void setRadarCoverageAltitudeMap(const ColorMap&);
      virtual const ColorMap& radarCoverageAltitudeMap() const;

      virtual void addRadarCoverageAltitude(double, unsigned int);

      virtual bool removeRadarCoverageAltitude(double);

      virtual void setRadarCoverageAltitudeMap(const DtRadarCoverageAltitudeSettings::AltitudeMap&);

      virtual void setKeyBackgroundColor(unsigned int);
      virtual unsigned int keyBackgroundColor() const;
      virtual void keyBackgroundColorOSG(float& r, float& g, float& b, float& a) const;

      virtual void setKeyFontColor(unsigned int);
      virtual unsigned int keyFontColor() const;
      virtual void keyFontColorOSG(float& r, float& g, float& b, float& a) const;

      virtual void setShowLabels(bool);
      virtual bool showLabels() const;

      virtual bool hasRadarCoverage(const makVrv::DtSelectionManager::IdSet&);
      virtual bool hasRadarCoverage(makVrv::DtUniqueID);
      
      virtual bool isMonitoring() const;

      virtual bool isMonitoring(const DtUUID&) const;

      boost::signals2::signal<void (bool)> signal_altitudeMSLChanged;
      boost::signals2::signal<void (float r, float g, float b, float a)> signal_keyBackgroundColorChanged;
      boost::signals2::signal<void (float r, float g, float b, float a)> signal_keyFontColorChanged;
      boost::signals2::signal<void (const ColorMap&)> signal_radarCoverageAltitudesChanged;
      boost::signals2::signal<void (const DtUUID&)> signal_radarCoverageMonitored;
      boost::signals2::signal<void (const DtUUID&)> signal_radarCoverageStoppedMonitoring;
      boost::signals2::signal<void (double)> signal_alphaChanged;
      boost::signals2::signal<void (float r, float g, float b, float a)> signal_waitingColorChanged;

   protected:
      virtual void completeSetup();
      virtual void slot_simObjectEntryAboutToBeRemoved(makVrv::DtSimObjectEntry& entry);
      virtual void slot_settingReceived(const std::string& s, const DtVrfBackendState* state);
      virtual void processRadarCoverageAltitudeSettings(const DtRadarCoverageAltitudeSettings&);
      virtual void slot_radarCoverageEnabled(const DtUUID&, int);
      virtual void slot_setupRadarCoverage();
      virtual void slot_intervisibilityElementAboutToBeDestroyed(makVrv::DtIntervisibilityElement*);

      virtual void processRadarCoverageData(DtSimMessage* msg);
      virtual void processRadarCoverage(const DtIfRadarCoverageInformationResponse& s);

      struct RadarCoverageVisual;

      virtual bool createRadarCoverageVisuals(const DtIfRadarCoverageInformationResponse&);

      virtual void processWaitingVisuals();

      virtual void slot_onStateViewUpdated(makVrv::DtStateView<makVrv::DtVrlinkSimulatedBaseState>* stateView, DtIfRadarCoverageInformationResponse*);

   protected:
      makVrv::DtDe&                       myDe;

      typedef std::map<DtUUID, int>  MonitoringMap;
      MonitoringMap                     myMonitoring;

      typedef std::map<makVrv::DtUniqueID, DtUUID> MonitoringByIdMap;
      MonitoringByIdMap myMonitoringById;

      makVrv::DtSignalConnectionManager myConnections;
      bool myAltitudeMSL;
      makVrv::DtRecordSettingsBackupInterface* mySettingsBackup;

      ColorMap myRadarCoverageAltitudes;

      typedef std::map<DtUUID, std::map<bool, int> > RequestIds;
      RequestIds myRequestIds;

      struct RadarCoverageVisual
      {
         DtIntervisibilitySensorFanStateListener* listener;
         makVrv::DtIntervisibilityElement* element;
      };

      typedef std::map<DtString, RadarCoverageVisual> RadarCoverageVisuals;
      typedef std::map<DtUUID, RadarCoverageVisuals> RadarCoverageVisualsMap;

      RadarCoverageVisualsMap myRadarCoverageVisualsMap;

      typedef std::map<bool, DtIfRadarCoverageInformationResponse*> WaitingForVisuals;
      typedef std::map<DtUUID, WaitingForVisuals> WaitingForVisualsMap;
      WaitingForVisualsMap myWaitingForVisualsMap;

      boost::signals2::connection myWaitingConnection;

      typedef std::map<DtUUID, std::map<bool, boost::signals2::connection> > UpdateConnections;
      UpdateConnections myUpdateConnections;

      std::set<int> myPendingRequestIds;
   };

   class DT_DLL_VRFGUICORE DtSharedRadarCoverageSettingsSignaler : public makVrv::DtVirtualBaseClass
   {
   public:

      static DtSharedRadarCoverageSettingsSignaler& instance(const makVrv::DtSharedSettingsManager&);

      static DtSharedRadarCoverageSettingsSignaler& instance(makVrv::DtEventQueueInterface&);

      static DtSharedRadarCoverageSettingsSignaler* findInstance(
         makVrv::DtEventQueueInterface*);

      virtual ~DtSharedRadarCoverageSettingsSignaler();

      makVrv::event_signal<void (double)> signal_showLabelsChanged;

   protected:
      DtSharedRadarCoverageSettingsSignaler(makVrv::DtEventQueueInterface& eqi);

   private:
      DtSharedRadarCoverageSettingsSignaler(const DtSharedRadarCoverageSettingsSignaler&);
      DtSharedRadarCoverageSettingsSignaler& operator=(const DtSharedRadarCoverageSettingsSignaler&);
   };

   class DT_DLL_VRFGUICORE DtSharedRadarCoverageSettings : public makVrv::DtSharedSettings
   {
   public:

      friend class makVrv::DtReadSettingsLock<DtSharedRadarCoverageSettings>;
      friend class makVrv::DtWriteSettingsLock<DtSharedRadarCoverageSettings>;
      friend class makVrv::DtSharedSettingsManager;
      
      static std::string className();

      virtual ~DtSharedRadarCoverageSettings();

      virtual void getRecord(DtRadarCoverageSettingsRecord& rec) const;
      virtual void setFromRecord(const DtRadarCoverageSettingsRecord& rec);

      virtual void setAlpha(double d);
      virtual double alpha() const;

      virtual void setWaitingForServerColor(unsigned int);
      virtual unsigned int waitingForServerColor() const;
      virtual void waitingForServerColorOSG(float& r, float& g, float& b, float& a) const;

      virtual void setKeyBackgroundColor(unsigned int);
      virtual unsigned int keyBackgroundColor() const;
      virtual void keyBackgroundColorOSG(float& r, float& g, float& b, float& a) const;

      virtual void setShowLabels(bool);
      virtual bool showLabels() const;

      virtual void setKeyFontColor(unsigned int);
      virtual unsigned int keyFontColor() const;
      virtual void keyFontColorOSG(float& r, float& g, float& b, float& a) const;

   protected:

      DtSharedRadarCoverageSettings(makVrv::DtSharedSettingsManager& manager);

   protected:
      DtRadarCoverageSettingsRecord mySettingsRecord;
   };
}