rangeRingsManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/rangeRingsSettingsRecord.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtSharedSettings.h>
#include <vrvUtil/event_signal.h>
#include <vrvUtil/DtUnicode.h>
#include <vlpi/netStructs.h>

#include <set>

namespace makVrv
{
   class DtRecordSettingsBackupInterface;
   class DtEventQueueInterface;
   class DtSharedSettingsManager;
   class DtDe;
}

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtSharedRangeRingsSettings : public makVrv::DtSharedSettings
   {
   public:

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

      virtual ~DtSharedRangeRingsSettings() override;

      virtual void setFill2D(bool);
      virtual bool fill2D() const;

      virtual void setShowRangeSphere(bool);
      virtual bool showRangeSphere() const;

      virtual void setShowWeaponNameLabel( bool );
      virtual bool showWeaponNameLabel() const;

      virtual void setShowEntityNameLabel( bool );
      virtual bool showEntityNameLabel() const;

      virtual void setShowRangeValueLabel( bool );
      virtual bool showRangeValueLabel() const;

      virtual void setShowByDefault( bool );
      virtual bool showByDefault() const;

      virtual void setShowForSelected( bool );
      virtual bool showForSelected() const;

      virtual void setShowPhysicalFootprint( bool );
      virtual bool showPhysicalFootprint() const;

      virtual void setSphereOpacityModifier(double);
      virtual double sphereOpacityModifier() const;

      virtual void setAttackAnimationForRingEnabled(const std::string&, bool);
      virtual bool attackAnimationForRingEnabled(const std::string&) const;

      virtual const DtRangeRingsSettingsRecord::ColorOptions& colorOptions() const;
      virtual DtRangeRingsSettingsRecord::ColorOption colorOption(const std::string&) const;

      virtual void setColorOptions(const DtRangeRingsSettingsRecord::ColorOptions&);
      virtual bool getColor(const std::string& type, int force, float& r, float& g, float& b, float& a, makVrv::DtUnicode&) const;
      virtual void setColor(const std::string& type, int color, const  makVrv::DtUnicode&);
      virtual void removeColorOption(const std::string& type);

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

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

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

      virtual void addColorOptionIfMissing(const std::string& option, int color, const makVrv::DtUnicode& label,
         bool visible = true);

      virtual bool getColorByCategory(const std::string& type, int& color) const;

      virtual makVrv::DtUnicode labelForType(const std::string&) const;
      virtual void setVisible(const std::string& type, bool);
      virtual bool visible(const std::string& type) const;
      virtual bool wasRequested(const std::string&) const;

      virtual void setSectorSizeProperty(const std::string&);
      virtual const std::string& sectorSizeProperty() const;

      virtual bool hasNewOptions() const;
      virtual void getAndClearOptions(std::set<std::string>& newOptions, std::set<std::string>& newOptionsRequested);

   protected:
      virtual void colorFromForce(int force, float& r, float& g, float& b);

   protected:

      DtSharedRangeRingsSettings(makVrv::DtSharedSettingsManager& manager);

   protected:
      bool myFill2D;
      bool myShowRangeSphere;
      bool myShowWeaponNameLabel;
      bool myShowEntityNameLabel;
      bool myShowRangeValueLabel;

      bool myShowByDefault;
      bool myShowForSelected;
      bool myShowPhysicalFootprint;
      
      double mySphereOpacityModifier;

      DtRangeRingsSettingsRecord::ColorOptions myColorOptions;

      std::map<std::string, bool> myRequested;
      std::map<std::string, bool> myAttackAnimationEnabled;
      std::string mySectorSizeProperty;

      std::set<std::string> myNewColorOptions;
      std::set<std::string> myNewOptionRequested;
   };

   class DT_DLL_VRFGUICORE DtRangeRingsManager : public makVrv::DtVirtualBaseClass
   {
   public:
      DtRangeRingsManager(makVrv::DtDe&);
      virtual ~DtRangeRingsManager() override;

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

      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(DtRangeRingsSettingsRecord& rec) const;
      virtual void setFromRecord(const DtRangeRingsSettingsRecord& rec);

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

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

      virtual void setFill2D(bool b);
      virtual bool fill2D() const;

      virtual void setShowRangeSphere( bool onOff );
      virtual bool showRangeSphere() const;

      virtual void setShowWeaponNameLabel( bool );
      virtual bool showWeaponNameLabel() const;

      virtual void setShowEntityNameLabel( bool );
      virtual bool showEntityNameLabel() const;

      virtual void setShowRangeValueLabel( bool );
      virtual bool showRangeValueLabel() const;

      virtual void setShowByDefault( bool );
      virtual bool showByDefault() const;

      virtual void setShowForSelected( bool );
      virtual bool showForSelected() const;

      virtual void setShowPhysicalFootprint( bool );
      virtual bool showPhysicalFootprint() const;

      virtual void setSphereOpacityModifier(double);
      virtual double sphereOpacityModifier() const;

      virtual const DtRangeRingsSettingsRecord::ColorOptions& colorOptions() const;
      virtual DtRangeRingsSettingsRecord::ColorOption colorOption(const std::string&) const;
      virtual void setColorOptions(const DtRangeRingsSettingsRecord::ColorOptions&);
      virtual bool getColor(const std::string& type, int force, float& r, float& g, float& b, float& a, makVrv::DtUnicode&) const;
      virtual void setColor(const std::string& type, int color, const makVrv::DtUnicode&);
      virtual void setVisible(const std::string& type, bool);
      virtual bool visible(const std::string& type) const;

      virtual void setAttackAnimationForRingEnabled(const std::string&, bool);
      virtual bool attackAnimationForRingEnabled(const std::string&) const;

      virtual void removeColorOption(const std::string& type);
      virtual bool wasRequested(const std::string&) const;

      virtual void addColorOptionIfMissing(const std::string& option, int color, const makVrv::DtUnicode& label,
         bool visible = true);

      virtual makVrv::DtUnicode labelForType(const std::string&) const;

      virtual std::string sectorSizeProperty() const;
      virtual void setSectorSizeProperty(const std::string&);

   protected:
      virtual void completeSetup();

   protected:
      makVrv::DtDe& myDe;
      makVrv::DtRecordSettingsBackupInterface* mySettingsBackup;
   };

   class DT_DLL_VRFGUICORE DtSharedRangeRingsSettingsSignaler : public makVrv::DtVirtualBaseClass
   {
   public:

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

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

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

      virtual ~DtSharedRangeRingsSettingsSignaler() override;

      makVrv::event_signal<void (bool)> signal_fill2DChanged;
      makVrv::event_signal<void (bool)> signal_rangeSphereToggled;
      makVrv::event_signal<void (std::string, bool)> signal_visibilityChanged;
      makVrv::event_signal<void ()> signal_labelSettingsChanged;
      makVrv::event_signal<void ()> signal_colorsChanged;
      makVrv::event_signal<void (std::string, bool)> signal_attackAnimationForRingChanged;

      makVrv::event_signal<void ()> signal_showByDefaultChanged;
      makVrv::event_signal<void ()> signal_showForSelectedChanged;
      makVrv::event_signal<void ()> signal_showPhysicalFootprintChanged;
      makVrv::event_signal<void (double)> signal_sphereOpacityModifierChanged;

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

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

inline  const bool operator==(const std::vector<DtNetFloat32>& lhs, const std::vector<double>& rhs)
{
   if (lhs.size() != rhs.size())
   {
      return false;
   }
   else
   {
      std::vector<DtNetFloat32>::const_iterator lhsIter = lhs.begin();
      std::vector<DtNetFloat32>::const_iterator lhsEnd = lhs.end();
      std::vector<double>::const_iterator rhsIter = rhs.begin();
      std::vector<double>::const_iterator rhsEnd = rhs.end();

      for (;lhsIter != lhsEnd; ++lhsIter, ++rhsIter)
      {
         if (*rhsIter != *lhsIter)
         {
            return false;
         }
      }
   }

   return true;
}

inline const bool operator!=(const std::vector<DtNetFloat32>& lhs, const std::vector<double>& rhs)
{
   return !(operator==(lhs, rhs));
}

inline const bool operator==(const std::vector<double>& lhs, const std::vector<DtNetFloat32>& rhs)
{
   if (lhs.size() != rhs.size())
   {
      return false;
   }
   else
   {
      std::vector<double>::const_iterator lhsIter = lhs.begin();
      std::vector<double>::const_iterator lhsEnd = lhs.end();
      std::vector<DtNetFloat32>::const_iterator rhsIter = rhs.begin();
      std::vector<DtNetFloat32>::const_iterator rhsEnd = rhs.end();

      for (;lhsIter != lhsEnd; ++lhsIter, ++rhsIter)
      {
         if (*rhsIter != *lhsIter)
         {
            return false;
         }
      }
   }

   return true;
}

inline const bool operator!=(const std::vector<double>& lhs, const std::vector<DtNetFloat32>& rhs)
{
   return !(operator==(lhs, rhs));
}