objectSettingsManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfutil/rwColor.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrfGuiCore/guiScenarioSettingsManager.h>
#include <vrfGuiCore/guiSimObject.h>
#include <vrvCore/DtSharedSettings.h>
#include <vrvCore/DtElementEntry.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtSharedSettings.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtElementAttributeManager.h>
#include <vrvUtil/DtUnicode.h>
#include <vrvUtil/event_signal.h>

#include <boost/function.hpp>
#include <unordered_set>

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

namespace makVrf
{
   enum ObjectSetting
   {
      ObjectSettingsRangeRings = 0x00000001,
      ObjectSettingsSensorContacts = 0x00000002,
      ObjectSettingsTaskVisualizations = 0x00000004,
      ObjectSettingsReportTrackHistory = 0x00000008,
      ObjectSettingsRadarCoverage = 0x00000010,
      ObjectSettingsUnitCollapsed = 0x00000020,
      UserStart = 0x01000000
   };

   class DT_DLL_VRFGUICORE DtSharedObjectSettings : public makVrv::DtSharedSettings
   {
   public:
      typedef std::map<DtUUID, ObjectSetting> ObjectSettingsMap;

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

      virtual ~DtSharedObjectSettings() override;

      virtual void removeSettings(const DtUUID&);

      void setSettings(const DtUUID&, ObjectSetting);
      ObjectSetting settingsFor(const DtUUID&) const;

      virtual bool hasSetting(const DtUUID&) const;

      void setFlagState(const DtUUID&, ObjectSetting, bool onOff);

      bool flagState(const DtUUID&, ObjectSetting) const;

      virtual void write(boost::archive::xml_oarchive& ar, int version) const;
      virtual void read(boost::archive::xml_iarchive& ar, int version);

      const ObjectSettingsMap& settingsMap() const;

      virtual bool setSelectedForDisplay(int setting, const DtUUID& uuid, bool flag);

      virtual bool availableToShowForSelection(int setting, const DtUUID&, int shownByDefault = 0) const;

      virtual void removeAllPinnedSettings(int flag);

      virtual void setMaximumToDisplayBeforeHidingAllFromSelection(int setting, int maximum, bool replaceIfSet = true);

      virtual DtUUID getAvailableUUIDForDisplay(int setting, int shownByDefault = 0) const;

      virtual void settingsLoaded();

   protected:

      DtSharedObjectSettings(makVrv::DtSharedSettingsManager& manager);

   protected:
      ObjectSettingsMap mySettings;

      struct SelectionSettings
      {
         int maximumToDisplayBeforeHidingAllFromSelection = 1;
         std::unordered_set<DtUUID> showingForSelection;
      };

      typedef std::map<ObjectSetting, SelectionSettings> SelectionSettingsMap;
      SelectionSettingsMap mySelectionSettingsMap;
   };

   class DT_DLL_VRFGUICORE DtObjectSettingsManager : public DtGuiSetting
   {
   public:
      typedef boost::function<bool (const makVrv::DtSelectionManager::IdSet&)> SettingsValidationFunction;

      struct ObjectSettingStruct
      {
         ObjectSettingStruct(ObjectSetting s, makVrv::DtUnicode n, std::set<makVrv::DtElementEntry::ElementType> e, bool unpinnable)
         : setting(s)
         , name(s)
         , validFor(e)
         , unpinnable(unpinnable)
         {
         }

         ObjectSettingStruct()
         : setting((ObjectSetting)0)
         , validFor()
         , unpinnable(true)
         {
            validFor.insert( makVrv::DtElementEntry::Unknown );
         }

         ObjectSettingStruct(const ObjectSettingStruct& s)
         : setting(s.setting)
         , name(s.name)
         , validFor(s.validFor)
         , validation(s.validation)
         , unpinnable(s.unpinnable)
         {
         }

         ObjectSettingStruct& operator=(const ObjectSettingStruct& s)
         {
            setting = s.setting;
            name = s.name;
            validFor = s.validFor;
            validation = s.validation;
            unpinnable = s.unpinnable;

            return *this;
         }

         ObjectSetting setting;
         bool unpinnable;
         makVrv::DtUnicode name;
         SettingsValidationFunction validation;
         std::set<makVrv::DtElementEntry::ElementType> validFor;
      };

      typedef std::vector<ObjectSettingStruct> ObjectSettings;
     
   public:
      DtObjectSettingsManager(makVrv::DtDe&);
      virtual ~DtObjectSettingsManager() override;

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

      virtual void removeSettings(const DtUUID&);

      virtual void removeAll();

      virtual void setSettings(const DtUUID&, ObjectSetting);
      ObjectSetting settingsFor(const DtUUID&) const;
     
      virtual DtRwColor iconColorSettings(const DtUUID&) const;

      virtual void setIconColorSettings(DtUUID&, DtRwColor color);
      virtual void setIconColorSettings(const std::vector<DtUUID>& names, DtRwColor color);
     
      //check if the icon color has changed
      virtual bool iconColorChanged(const DtUUID&);

      virtual void setMaximumToDisplayBeforeHidingAllFromSelection(int setting, int maximum, bool replaceIfSet = true);

      virtual DtUUID getAvailableUUIDForDisplay(int setting) const;

      typedef std::map<DtUUID, DtRwColor> IconColorMap;
      boost::signals2::signal<void(DtRwColor, std::vector<makVrv::DtUniqueID>)> signal_iconColorSettingsChanged;

      virtual DtObjectSettingsManager::ObjectSettingStruct addSetting(const makVrv::DtUnicode&, 
         ObjectSetting, std::set<makVrv::DtElementEntry::ElementType> validFor, bool unpinnable = true,
         SettingsValidationFunction = boost::bind(&DtObjectSettingsManager::alwaysValid));
      virtual void removeSetting(ObjectSetting);
      ObjectSetting settingFor(const makVrv::DtUnicode&);
      makVrv::DtUnicode settingNameFor(ObjectSetting);

      virtual void removeAllPinnedSettings();

      virtual void removeAllPinnedSettings(int flag, bool signalScenarioModified = true);

      bool flagState(const DtUUID&, ObjectSetting) const;
      virtual void setFlagState(const DtUUID&, ObjectSetting, bool onOff);
      const ObjectSettings& objectSettings() const;

      virtual bool hasSetting(const DtUUID&) const;
      virtual bool hasRadarCoverage(const makVrv::DtSelectionManager::IdSet&);

      virtual void protect();

      virtual void unprotect();

      virtual bool validFor(ObjectSetting, const makVrv::DtSelectionManager::IdSet&) const;

      virtual void slot_attributesModified(const makVrv::DtElementAttributeManager::EntryAttributesList& l);

   protected:
      static bool alwaysValid();

      virtual void init();

      virtual void write(boost::archive::xml_oarchive& ar, int version) const override;
      virtual void read(boost::archive::xml_iarchive& ar, int version) override;

      virtual void slot_onObjectAboutToBeRemoved(DtSimObjectReference s);

      virtual void slot_onObjectAdded(DtSimObjectReference p);

      virtual void slot_uuidChanged(const DtUUID& oldUUID, const DtUUID& newUUID, DtSimObjectReference ref);

      virtual void setupInitialValues();

   protected:
      makVrv::DtDe& myDe;
      ObjectSettings myObjectSettings;
      IconColorMap myIconColorMap;
      makVrv::DtSignalConnectionManager myConnectionManager;

      typedef std::map<DtUUID, bool> ProtectedFromRemoval;
      ProtectedFromRemoval myProtectedFromRemoval;
      boost::signals2::scoped_connection myDePostTickConnection;
   };

   class DT_DLL_VRFGUICORE DtSharedObjectSettingsSignaler : public makVrv::DtVirtualBaseClass
   {
   public:

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

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

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

      virtual ~DtSharedObjectSettingsSignaler() override;

      makVrv::event_signal<void (DtUUID, ObjectSetting)> signal_settingsChanged;
      makVrv::event_signal<void ()> signal_settingsLoaded;

      makVrv::event_signal<void (ObjectSetting)> signal_selectionDisplayAvailableChangedFor;

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

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