DtElementIDHierarchy.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>

#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/signalslib.h>
#include <boost/unordered_map.hpp>
#include <boost/function.hpp>

#include <set>

namespace makVrv
{
   class DtElementIDHierarchyState;

   class DT_DLL_VRVCORE DtElementIDHierarchyNode
   {
   public:
      typedef std::vector<DtElementIDHierarchyNode*> ChildHierarchyNodes;

      enum DisplayState
      {
         Unknown = -1,
         Collapsed = 0,
         Shown = 1,
         Ghosted = 2,
         Expanded = 3,
         InitiallyShown = 4,        
         InitiallyExpanded = 5,     
         Hidden = 6,
      };

      enum Flags
      {
         ShouldHaveChildren = 0x00000001, 
         CollapseIfNoChildren = 0x00000002, 
      };
      
      DtElementIDHierarchyNode();

      DtElementIDHierarchyNode(DtElementID id, const DtElementIDHierarchyState&);

      DtElementIDHierarchyNode(DtElementID);
      DtElementIDHierarchyNode(const DtElementIDHierarchyNode& orig);

      virtual ~DtElementIDHierarchyNode();

      DtElementIDHierarchyNode& operator=(const DtElementIDHierarchyNode&);
      bool operator==(const DtElementIDHierarchyNode&) const;
      bool operator!=(const DtElementIDHierarchyNode& rhs) const
      {
         return !(*this == rhs);
      }

      bool hasChild(DtElementID child) const;
      bool addChild(DtElementIDHierarchyNode*);
      void removeChild(DtElementID child);
      void copyOriginal(const DtElementIDHierarchyNode& orig);

      const makVrv::DtElementID& uniqueId() const;
      const ChildHierarchyNodes& children() const;

      void removeAllChildren();
      void setParent(DtElementIDHierarchyNode* p);

      DtElementIDHierarchyNode* parent();
      const DtElementIDHierarchyNode* parent() const;

      virtual bool childInHierarchy(DtElementID id) const;

      void setFlags(int flags);
      int flags() const;

      void setDisplayState(DisplayState);
      DisplayState displayState() const;

   protected:
      DtElementIDHierarchyNode*  myParent;
      ChildHierarchyNodes        myChildren;
      DtElementID                myId;
      bool                       myCleanupChildren;
      int                        myFlags;
      DisplayState               myDisplayState;
   };

   class DT_DLL_VRVCORE DtElementIDHierarchy
   {
   public:
      typedef std::vector<DtElementID> ElementIDs;
      typedef std::set<const DtElementIDHierarchyNode*>  VisibilityProcessingList;
      typedef boost::function<DtElementIDHierarchyNode::DisplayState (const DtElementIDHierarchyNode*)> ExpectedDisplayState;

   public:
      DtElementIDHierarchy();
      virtual ~DtElementIDHierarchy();

   public:
      virtual void addToHierarchy(DtElementID elementID, DtElementID child, int flags = 0, bool setAsNewChildren = true,
         bool processList = true);
      virtual void addToHierarchy(DtElementID elementID, const ElementIDs& children = ElementIDs(),
         int flags = 0, bool setAsNewChildren = true, bool processList = true);

      void setFlags(DtElementID id, int flags);

      int flags(DtElementID id) const;

      virtual void removeFromHierarchy(DtElementID id);

   public:
      virtual bool isChild(DtElementID parentId, DtElementID childId, bool recurse = false) const;

      bool isInHierarchy(DtElementID id) const;

      DtElementIDHierarchyNode* parentOf(DtElementID id);
      const DtElementIDHierarchyNode* parentOf(DtElementID id) const;

      DtElementIDHierarchyNode* hierarchyNode(DtElementID id);
      const DtElementIDHierarchyNode* hierarchyNode(DtElementID elementID) const;

      bool hasChildren(DtElementID id) const;

      int level(const DtElementIDHierarchyNode* node) const;

      virtual DtElementIDHierarchyNode::DisplayState displayState(DtElementID elementID) const;

      virtual void detachChildFromParent(DtElementID child);

      virtual void attachChildToParent(DtElementID child, DtElementID parent, bool processList = true);

   public:

      virtual void expand(DtElementID elementID, bool processList = true);

      virtual void expandAll(DtElementID elementID, bool processList = true);

      virtual void expandDown(DtElementID elementID, int numLevels = -1, bool processList = true);

      virtual void collapseAll(DtElementID elementID, bool processList = true);

      virtual void collapse(DtElementID elementID, bool processList = true);

      virtual void processVisibilityList();

      void setInitiallyExpanded(bool);
      virtual bool initiallyExpanded() const;

      virtual void processNode(DtElementIDHierarchyNode* node, bool forceUpdate = false);

      void setExpectedDisplayStateFunction(ExpectedDisplayState);

      virtual DtElementIDHierarchyNode::DisplayState expectedDisplayStateFor(const DtElementIDHierarchyNode* node); 

      virtual void reprocessAllNodes();

      virtual void updateHierarchyToMatch(DtElementID id, const ElementIDs& children, int flags);

   public:
      //Comparison of two DtElementIDHierarchyNode's uniqueIds. Return true if a->uniqueId() < b->uniqueId()
      static bool nodeUniqueIdSort(DtElementIDHierarchyNode* a, DtElementIDHierarchyNode* b);


   protected:
      virtual void processVisibilityState(const DtElementIDHierarchyNode*);

      virtual void processSingleNode(DtElementIDHierarchyNode* node, bool forceUpdate = false);
      virtual void processParentedNode(DtElementIDHierarchyNode* node, bool forceUpdate = false, bool processChildren = true);
      virtual void processNodeWithChildren(DtElementIDHierarchyNode* node, bool forceUpdate = false);

      virtual void attachParentToChildrenAndRemoveMissingChildren(DtElementID parentId, ElementIDs newChildren);

   protected:
      virtual void hierarchyUpdated();

      virtual void aboutToBeRemovedFromHierarchy(DtElementIDHierarchyNode*);

      virtual void updateHierarchy(DtElementID id, const ElementIDs& children, bool setAsNewChildren = true);

      virtual void attachParentToChildren(DtElementID parentId, const ElementIDs& children, bool setAsNewChildren = true);

      virtual void removeAllChildrenFromParent(DtElementID);

   public:
      boost::signalslib::signal<void (DtElementIDHierarchyNode*)   > signal_hierarchyItemModified;

      boost::signalslib::signal<void (DtElementIDHierarchyNode*)   > signal_hierarchyItemToBeRemoved;
      boost::signalslib::signal<void (DtElementIDHierarchyNode*)   > signal_hierarchyItemAboutToBeRemoved;
      boost::signalslib::signal<void (DtElementIDHierarchy*)   > signal_hierarchyUpdated;
      boost::signalslib::signal<void (DtElementID, const ElementIDs&)> signal_updateHierarchy;
      boost::signalslib::signal<void (DtElementID, DtElementIDHierarchyNode::DisplayState)> signal_echelonVisibilityChange;
      boost::signalslib::signal<void (VisibilityProcessingList)> signal_visibilityChanged;

   protected:
      virtual void hierarchyItemModified(DtElementIDHierarchyNode*);

   protected:
      typedef boost::unordered_map<DtElementID, DtElementIDHierarchyNode*> HierarchyNodeMap;

      HierarchyNodeMap myFlatHierarchy;
      VisibilityProcessingList myVisibilityProcessingList;
      ExpectedDisplayState     myExpectedDisplayState;

      bool myInitiallyExpanded;
   };
}