DtAggregateElementProcessor.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtAggregateElementProcessor.h,v $ $Revision: 1.17 $ $State: Exp $
******************************************************************************/


#pragma once

#include <vrvVrl/vrvVrl.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <boost/unordered_map.hpp>
#include <vl/globalObjDes.h>

#include <vrvCore/DtVisualizerSet.h>
#include <makArchives/DtAggregateSettingsRecord.h>
#include <vrvVrl/DtAggregateEchelonManager.h>

namespace makVrv
{
   class DtAggregateVisualizerSet;

   namespace DT_PROTOCOL_NAMESPACE
   {
      class DtAggregateElement;
      class DtVrlinkConnection;
      class DtVrlinkAggregateStateListener;
      class DtVrlinkAggregateListener;

      class DL_DLL_IGCONVRLINK DtAggregateElementProcessor : public DtVirtualBaseClass
      {
      public:

         DtAggregateElementProcessor(DtVrlinkConnection& conn);

         static void registerInstance(DtVrlinkConnection& conn, 
            DtAggregateElementProcessor* instance);

         static DtAggregateElementProcessor* findInstance(DtVrlinkConnection& conn);

         virtual ~DtAggregateElementProcessor();

         DtAggregateVisualizerSet* findVisualizer(int modelSet,
            const DtGlobalObjectDesignator& id);

         std::vector<DtAggregateVisualizerSet*> findVisualizers(
            const DtGlobalObjectDesignator& id);

         DtAggregateVisualizerSet* findVisualizer( DtUniqueID sceneId );

         DtVrlinkAggregateStateListener* findListener( DtUniqueID elementId );
         
         DtAggregateElement* findElement( const DtUniqueID& elementId );
         
         DtAggregateElement* findElement( const DtGlobalObjectDesignator& id );

         void toggleLabelPinnedState(const DtSelectionManager::IdSet& ids);

         void changeAggregateSelection(const DtSelectionManager::IdSet& selected,
            const DtSelectionManager::IdSet& deselected);

         virtual void setAggregateSettings(const makArchives::DtAggregateSettingsRecord&);

         void setVisualizerCreationProcessingTime(double);
         double visualizerCreationProcessingTime() const;

      public:
         boost::signal<void (DtVrlinkAggregateStateListener&, DtAggregateElement*)> signal_elementCreated;
         boost::signal<void (DtVrlinkAggregateStateListener&, DtAggregateElement*)> signal_elementAboutToBeDestroyed;

      protected:

         virtual void modelSetVisualized(int modelSet, bool enabled);
         
         virtual void elementAttributeChangeRequested( DtUniqueID id, 
            DtUniqueID parentID, DtBoost::shared_ptr<const DtElementAttribute> atr );

         virtual void handleElementAttributeChanged(
            DtAggregateElement& entity, const DtElementAttribute* attr);
         
         virtual void onAggregateDiscovered(DtVrlinkAggregateStateListener& listener);

         virtual void onAggregateToBeDestroyed(DtVrlinkAggregateStateListener& listener);

         virtual void slot_echelonVisibilityChange(DtElementID, DtElementIDHierarchyNode::DisplayState);
         virtual void slot_echelonVisibilityChanged(DtElementIDHierarchy::VisibilityProcessingList);

         virtual void slot_aggregateDestroyedStateChanged(DtElementID, bool);

         virtual void processVisualizer(int modelSet, DtElementIDHierarchyNode::DisplayState displayState,
            DtElementID id, DtVisualizerSet* s, bool respectLeafFlag);

         virtual bool isGhostable(DtVisualizerSet* set) const;

         virtual double setTransparency(DtVisualizerSet* set, double t) const;

         virtual double currentTransparency(DtVisualizerSet* set) const;

         virtual void applyGhosting(int modelSet, DtElementID elementID, DtVisualizerSet*);

         virtual void removeGhosting(int modelSet, DtElementID elementID);

         virtual void setDisplayAggregates(bool b);

         virtual void setShowLeafNodes(bool b);

         virtual void setGhostEchelonLevelItems(bool b);

         virtual void setEchelonLevel(int i);

         virtual void setAllowSelectionOfGhostedItems(bool);

         virtual void slot_hierarchyItemModified(DtElementIDHierarchyNode*);

         virtual void slot_hierarchyItemToBeRemoved(DtElementIDHierarchyNode*);

         virtual void slot_subordinatesChanged(DtAggregateElement*);

         virtual void mapGlobalIdsToElementIds(DtElementID parent, 
            const std::set<std::string>& globalIds, DtElementIDHierarchy::ElementIDs& children);

         virtual void watchForGlobalIdDiscovery(DtElementID parent, const std::string& globalId);

         virtual void slot_entityElementCreated(DtVrlinkEntityStateListener&, DtEntityElement*);

         virtual void aggregateElementCreated(DtVrlinkAggregateStateListener&, DtAggregateElement*);

         virtual void removeFromWatchList(DtElementID id);

         virtual void connectToElementProcessor();
         virtual void disconnectFromElementProcessor();

         virtual void slot_completeDiscovery();

         virtual void createVisualizer(DtVrlinkAggregateStateListener&);

      protected:

         typedef boost::unordered_map<DtUniqueID, DtAggregateElement*>
            AggregateElementVisualizerMap;
         typedef boost::unordered_map<std::string, DtAggregateElement*> 
            GlobalIdToAggregateElementVisualizerMap;
         typedef boost::unordered_map<DtUniqueID, DtVrlinkAggregateStateListener*> 
            ToBeVisualizedMap;

         DtVrlinkConnection& myConnection;
         DtSignalConnectionManager myConnections;
         AggregateElementVisualizerMap myAggregateElementVisualizers;
         GlobalIdToAggregateElementVisualizerMap myGlobalIdToElementVisualizerMap;
         makArchives::DtAggregateSettingsRecord myAggregateSettings;

         DtAggregateEchelonManager&  myEchelonHierarchy;
         ToBeVisualizedMap myToBeVisualized;
         double myVisualizerCreationProcessingTime;

      protected:
         typedef boost::unordered_map<int, DtVisualizerSet*>   GhostPair;    
         typedef boost::unordered_map<DtElementID, GhostPair>  GhostMap;

         GhostMap                                  myGhostMap;

         typedef boost::unordered_map<std::string, DtElementID>   WatchList;
         WatchList myWatchList;
      };    
   }
}