vrfExtendedIntervisibilitySettings.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/vrfGuiApplicationSettings.h>
#include <vrfutil/radarCoverageAltitudeSettings.h>
#include <boost/signals2.hpp>

namespace makVrv
{
   class DtDe;
}

#define DtIntervisibilitySettingsLine "line"
#define DtIntervisibilitySettingsFan "fan"
#define DtIntervisibilitySettingsObjectFan "object_fan"

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtVrfExtendedIntervisibilitySettingsData : public DtVrfGuiApplicationSetting
   {
   public:
      struct Color
      {
         Color() : r(0.0f), g(0.0f), b(0.0f), a(0.0f) {};
         Color(unsigned int color)
         {
            r = ((float)COLOR_R(color) / 255.0f);
            g = ((float)COLOR_G(color) / 255.0f);
            b = ((float)COLOR_B(color) / 255.0f);
            a = ((float)COLOR_A(color) / 255.0f);
         }

         explicit Color(unsigned int iR, unsigned int iG, unsigned int iB, unsigned int iA)
            : r((float)iR / 255.0f)
            , g((float)iG / 255.0f)
            , b((float)iB / 255.0f)
            , a((float)iA / 255.0f)
         {
         }

         explicit Color(float iR, float iG, float iB, float iA)
            : r(iR)
            , g(iG)
            , b(iB)
            , a(iA)
         {
         }

         Color(const Color& orig) : r(orig.r), g(orig.g), b(orig.b), a(orig.a) {};
         Color& operator=(const Color& orig) { r = orig.r; g = orig.g; b = orig.b; a = orig.a;  return* this; };
         bool compare(float c1, float c2) const { return ((int)(c1 * 255.0f) == (int)(c2 * 255.0f)); };
         bool operator==(const Color& orig) const { return (compare(r, orig.r) && compare(g, orig.g) && compare(b, orig.b) && compare(a, orig.a)); };
         bool operator!=(const Color& orig) const { return !(*this == orig); };
         unsigned int color() const
         {
            return COLOR_TO_INT((int)(r * 255.0f), (int)(g * 255.0f), (int)(b * 255.0f), (int)(a * 255.0f));
         }

         float r, g, b, a; 
      };

      enum Flags
      {
         UseBackendForIntersections = 0x00000001,
         IntersectTerrain = 0x00000002,
         IntersectFeatures = 0x00000004,
         IntersectEntities = 0x00000008,
         WaitForServer = 0x00000010,

         Defaults = UseBackendForIntersections | IntersectTerrain
      };

      struct IntervisibilitySettings
      {
         IntervisibilitySettings();
         IntervisibilitySettings(const IntervisibilitySettings& orig);

         int      flags;
         double   alpha;
         double   waitTimeRequest;
         double   fanModeSamplingRate;
         unsigned int waitingForServerColor;

         friend class boost::serialization::access;

         Color waitingForServerColorRGBA() const
         {
            return Color(COLOR_R(waitingForServerColor), COLOR_G(waitingForServerColor),
               COLOR_B(waitingForServerColor), COLOR_A(waitingForServerColor));
         }

         bool useBackendForIntersections() const
         {
            return ((flags & UseBackendForIntersections) != 0);
         }

         bool intersectTerrain() const
         {
            return ((flags & IntersectTerrain) != 0);
         }

         bool intersectFeatures() const
         {
            return ((flags & IntersectFeatures) != 0);
         }

         bool intersectEntities() const
         {
            return ((flags & IntersectEntities) != 0);
         }

         bool waitForServer() const
         {
            return ((flags & WaitForServer) != 0);
         }


         template<class Archive>
            void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(flags);
            ar & BOOST_SERIALIZATION_NVP(waitTimeRequest);
            ar & BOOST_SERIALIZATION_NVP(fanModeSamplingRate);
            ar & BOOST_SERIALIZATION_NVP(waitingForServerColor);
         }
      };

   public:
      DtVrfExtendedIntervisibilitySettingsData(makVrv::DtDe* de = 0);
      DtVrfExtendedIntervisibilitySettingsData(const DtVrfExtendedIntervisibilitySettingsData&);

      virtual ~DtVrfExtendedIntervisibilitySettingsData() override;

      virtual void setUseBackendForIntersections(const std::string& key, bool);
      virtual bool useBackendForIntersections(const std::string& key) const;

      virtual void setIntersectTerrain(const std::string& key, bool);
      virtual bool intersectTerrain(const std::string& key) const;

      virtual void setIntersectFeatures(const std::string& key, bool);
      virtual bool intersectFeatures(const std::string& key) const;

      virtual void setIntersectEntities(const std::string& key, bool);
      virtual bool intersectEntities(const std::string& key) const;

      virtual void setFanModeSamplingRate(const std::string& key, double);
      virtual double fanModeSamplingRate(const std::string& key) const;

      virtual DtVrfGuiApplicationSetting* clone() const override;

      virtual std::string classType() const override;

      virtual const IntervisibilitySettings& settingsFor(const std::string& key) const;
      virtual IntervisibilitySettings& settingsFor(const std::string& key);

      virtual void write(boost::archive::xml_oarchive& out, const unsigned int) override;
      virtual void read(boost::archive::xml_iarchive& in, const unsigned int) override;

      virtual void setWaitTimeRequest(const std::string& key, double);
      virtual double waitTimeRequest(const std::string& key) const;

      virtual void setWaitingForServerColor(const std::string& key, unsigned int);
      virtual unsigned int waitingForServerColor(const std::string& key) const;

      virtual void setWaitForServer(const std::string& key, bool);
      virtual bool waitForServer(const std::string& key) const;

      virtual int dataVersion() override { return 1; };

   protected:
      virtual void setFlag(const std::string& key, Flags, bool);
      virtual bool flagSet(const std::string&, Flags) const;

   protected:
      typedef std::map<std::string, IntervisibilitySettings> ExtendedSettings;
      mutable ExtendedSettings myExtendedSettings;
   };

   class DT_DLL_VRFGUICORE DtVrfExtendedIntervisibilitySettings : public makVrv::DtVirtualBaseClass
   {
   public:
      DtVrfExtendedIntervisibilitySettings(makVrv::DtDe&);

      virtual ~DtVrfExtendedIntervisibilitySettings() override;

      virtual const DtVrfExtendedIntervisibilitySettingsData::IntervisibilitySettings& settingsFor(const std::string& key) const;
      virtual DtVrfExtendedIntervisibilitySettingsData::IntervisibilitySettings& settingsFor(const std::string& key);

      virtual void setUseBackendForIntersections(const std::string& key, bool);
      virtual bool useBackendForIntersections(const std::string& key) const;

      virtual void setIntersectTerrain(const std::string& key, bool);
      virtual bool intersectTerrain(const std::string& key) const;

      virtual void setIntersectFeatures(const std::string& key, bool);
      virtual bool intersectFeatures(const std::string& key) const;

      virtual void setIntersectEntities(const std::string& key, bool);
      virtual bool intersectEntities(const std::string& key) const;

      virtual void setWaitTimeRequest(const std::string& key, double);
      virtual double waitTimeRequest(const std::string& key) const;

      static DtVrfExtendedIntervisibilitySettings& instance( makVrv::DtDe& de );
      static void registerInstance(makVrv::DtDe&, DtVrfExtendedIntervisibilitySettings*);

      virtual void setWaitingForServerColor(const std::string&, unsigned int);
      virtual unsigned int waitingForServerColor(const std::string&) const;

      virtual void setFanModeSamplingRate(const std::string& key, double);
      virtual double fanModeSamplingRate(const std::string& key) const;

      virtual void setWaitForServer(const std::string&, bool);
      virtual bool waitForServer(const std::string&) const;

      boost::signals2::signal<void (const std::string&, DtVrfExtendedIntervisibilitySettingsData::IntervisibilitySettings)> signal_extendedIntervisibilityOptionsChanged;

   protected:
      makVrv::DtDe& myDe;
   };
}