vrfTacticalGraphicOverlayManager.h

Go to the documentation of this file.

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



#pragma once


#include <vrfGuiCore/vrfGuiCore.h>
#include <vrvCore/DtTacticalGraphicOverlayManager.h>
#include <vrfGuiCore/guiSimObject.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtElementAttributeManager.h>
#include <QtCore/QString>

#include <map>
#include <set>

class DtSimulationObjectCategoryInformation;

namespace makVrv
{
   class DtSharedSettingsManager;
}

namespace makVrf
{
   class DtVrfSelectionFilter;

   class DT_DLL_VRFGUICORE DtVrfTacticalGraphicOverlayManager : public makVrv::DtTacticalGraphicOverlayManager
   {
   public:
      enum OverlayFlags
      {
         DisableRename = 0x00000001,
         DisableSelection = 0x00000002,
         DisableMove = 0x00000004,
         IsPersistent = 0x00000008,
         DisplayIcon = 0x00000010,
         CanUnlockOverlay = 0x00000020
      };

      typedef boost::function<void (DtSimObjectReference)> OverlayChecker;
      struct OrganizedCategory
      {
         OrganizedCategory() : rank(-1), filter(0), putOnOverlayBar(true), parentIdentifier(-1), identifier(0) {};

         DtString category;
         DtVrfSelectionFilter* filter;
         int rank;
         DtString displayName;
         DtString icon;
         bool putOnOverlayBar;
         OverlayChecker overlayChecker;
         int parentIdentifier;
         int identifier;
         std::set<int> children;
      };

      static const int AllVisible = 2;
      static const int SomeVisible = 1;
      static const int AllHidden = 0;

      DtVrfTacticalGraphicOverlayManager(makVrv::DtDe&);

      virtual ~DtVrfTacticalGraphicOverlayManager() override;

      static DtVrfTacticalGraphicOverlayManager& instance(makVrv::DtDe&);

      virtual void setOrganizedOverlayAvailable(const std::string& layerName, bool b);
      virtual bool alwaysAvailable(const std::string& layerName) const;

      virtual void setOverlayLayerVisible(const std::string& name, bool);

      virtual void slot_onElementAttributesChanged(
         const makVrv::DtElementAttributeManager::EntryAttributesList& attributes) override;

      virtual int overlayVisibilityState(const std::string&);

      virtual void setTacticalGraphicVisible(const makVrv::DtUniqueID& id, bool flag) override;

      virtual void setCanRenameOverlay(const std::string&, bool);
      virtual bool canRenameOverlay(const std::string&);

      virtual void setCanSelectOverlay(const std::string&, bool);
      virtual bool canSelectOverlay(const std::string&);

      virtual void setCanMoveFromOverlay(const std::string&, bool);
      virtual bool canMoveFromOverlay(const std::string&);

      virtual void setDisplayIcon(const std::string&, bool);
      virtual bool displayIcon(const std::string&);

      virtual void setIsPersistentOverlay(const std::string&, bool);
      virtual bool isPersistentOverlay(const std::string&);

      virtual void setCanUnlockOverlay(const std::string&, bool);
      virtual bool canUnlockOverlay(const std::string&);

      virtual DtFilename iconFilename(const std::string&) const;
      virtual DtString organizedCategoryName(int identifier) const;

      virtual void deleteOverlay(const std::string& name) override;

      virtual bool allObjectOnOverlayAreVrfSimulated(const std::string&) const;

      virtual void renameVrfOverlay(const std::string& oldName, const std::string& newName);

      virtual void renameOverlay(const std::string& oldName, const std::string& newName) override;

      virtual void hideOverlay(const std::string& overlay);

      virtual bool overlayHidden(const std::string&) const;
      virtual bool putOnOverlayBar(const std::string&) const;

      virtual void showOverlay(const std::string& overlay);

      virtual void setOverlayLocked(const std::string& overlayName, bool flag) override;
      virtual bool isOnLockedOverlay(makVrv::DtUniqueID) const;

      virtual void setOverlayDefaultHidden(const std::string& layer, bool);
      virtual bool overlayDefaultHidden(const std::string&) const;

      static QString organizeByCategoryOverlayName();

      virtual std::vector<std::string> overlaysForObject(makVrv::DtUniqueID id) const;

      virtual int organizedCategoryToIdentifier(const DtString& cat) const;
      virtual OrganizedCategory organizedCategory(const DtString& cat) const;
      virtual OrganizedCategory organizedCategory(int) const;

      virtual void addParentLayersIfDoNotExist(int parentIdentifier);

      virtual void addOverlay(const std::string&) override;

      virtual int addOrganizedCategory(const DtString& category, const DtVrfSelectionFilter&, int position, const DtString& icon, const DtString& displayName,
         bool putOnOverlayBar = true, int parentCategory = -1, OverlayChecker = 0);

      virtual void setAllowOnMoreThanOneLayer(int type, bool allow);

      virtual void setAllowOnMoreThanOneLayer(const std::string& type, bool allow);

      virtual void setOrganizedCategoryIcon(const DtString& category, const DtString& icon);
      virtual void setOrganizedCategoryDisplayName(const DtString& category, const DtString& title);

      virtual void setOrganizedCategoryIcon(int identifier, const DtString& icon);
      virtual void setOrganizedCategoryDisplayName(int identifier, const DtString& title);

      virtual void removeOrganizedCategory(const DtString& category);
      virtual void clearOrganizedCategories();
      virtual bool isOrganizedLayer(const std::string&) const;

      virtual std::string layerName(const std::string&) const;

      virtual void removeTacticalGraphic(const makVrv::DtUniqueID& id) override;
      virtual void renameTacticalGraphicOverlay(const makVrv::DtUniqueID& id, const std::string& newName) override;

      virtual int position(const std::string&) const;

      virtual std::set<std::string> organizedLayersFor(DtSimObjectReference) const;

      virtual int findBetterOrganizedChildOf(int parentIdentifier, DtSimObjectReference) const;

      virtual int numberOfOrganizedCategories() const;

      virtual std::string displayName(const std::string& layer) const;

      virtual bool isOnDefaultHiddenLayer(makVrv::DtUniqueID id) const;

      virtual void setOverlayVisible( const std::string& overlayName, bool flag ) override;

      virtual void neverAddThisEntityType(const DtEntityType& e);

      boost::signals2::signal<void (const std::string&, int)> signal_flagsChanged;
      boost::signals2::signal<void (const std::string&, bool)> signal_overlayHidden;
      boost::signals2::signal<void (const std::string&, bool)> signal_overlayLocked;
      boost::signals2::signal<void (const std::string&, int)> signal_overlayVisibilityStateChanged;
      boost::signals2::signal<void (const std::string&, bool)> signal_defaultHiddenChanged;
      boost::signals2::signal<void ()> signal_organizedCategoriesInitialized;
      boost::signals2::signal<void (const makVrv::DtElementID, bool& canBeOnMoreThanOneLayer)> signal_canBeOnMoreThanOneLayer;

   protected:
      virtual void initialize();
      virtual void objectAdded(DtSimObjectReference p);
      virtual void slot_organizeOverlaysByCategoryChanged(bool);

      virtual void setFlag(const std::string& s, OverlayFlags, bool);
      virtual bool testFlag(const std::string& s, OverlayFlags) const;

      virtual void updateLayerVisibilityThatHas(makVrv::DtUniqueID, bool b);

      virtual void addDefaultOrganizedCategories(const DtSimulationObjectCategoryInformation&);
      virtual void notifyLayerVisibilityChanged();

      virtual bool onlyOnOneLayer(const makVrv::DtElementID) const;
      virtual bool onlyOnOneLayer(DtSimObjectReference) const;
      virtual void slot_onElementsAdded(const makVrv::DtElementData::ElementList& elements) override;
      virtual void removeFromLayerIfFilterStateChanges(DtSimObjectReference, std::string);

      virtual void removeFromOrganizedLayer(makVrv::DtElementID, const std::string&);
      virtual void updateParentOverlayVisibilityStateOf(const std::string& overlayLayer, int newState);
      virtual void slot_attributesChanged(const makVrv::DtElementAttributeManager::EntryAttributesList& l);

   public:
      static DtString theOrganizedOverlayMarker;

   protected:
      std::vector<DtEntityType> myNeverAddThisEntityType;
      std::set<int> myAllowOnMoreThanOneLayer;
      std::set<std::string> myAllowGlobalIdOnMoreThanOneLayer;
      DtEntityType myStealthType;
      makVrv::DtSharedSettingsManager* mySettingsManager;

      typedef std::map<std::string, int> OverlayFlagsMap;
      OverlayFlagsMap myOverlayFlags;

      std::set<std::string> myOverlaysHidden;

      typedef std::map<std::string, DtVrfSelectionFilter*> VisibilityFilters;
      VisibilityFilters myVisibilityFilters;

      typedef std::map<int, OrganizedCategory> OrganizedCategories;
      OrganizedCategories myOrganizedCategories;

      struct MemberInfo
      {
         MemberInfo() : numHidden(0), numVisible(0) {};

         int numHidden;
         int numVisible;
         std::map<makVrv::DtUniqueID, bool> visibilityMap;
      };

      typedef std::map<std::string, MemberInfo> Members;
      Members myMembers;

      boost::signalslib::connection myVisibilityChangedConnection;
      std::map<std::string, int> myLayerVisibilityChanged;
      bool myOrganizeOverlaysByCategory;

      std::set<std::string> myAlwaysAvailable;

      typedef std::map<makVrv::DtUniqueID, makVrv::DtSignalConnectionManager> ConnectionManagerMap;
      typedef std::map<std::string, ConnectionManagerMap> CheckConnections;
      CheckConnections myCheckConnections;

      struct TGChange
      {
         TGChange() : change(false) {};

         bool change;
         std::string val;
      };

      typedef std::pair<TGChange, TGChange> TGPair;

      std::map<makVrv::DtUniqueID, TGPair> myToChangeList;
      int myOrganizedCategoryIdentifier = 0;
   };
}