DtVisualizerSet.h

Go to the documentation of this file.

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


#pragma once 

#include <vrvCore/DtShowHideContext.h>
#include <vrvCore/DtStateVisualizer.h>
#include <vrvCore/DtVisualizerCreationSettings.h>
#include <vrvCore/DtMouseState.h>

#include <vrvCore/DtVisualizerSchema.h>

namespace makVrv
{
   class DtBaseConnection;
   class DtSceneObjectVisualizer;
   class DtStateListener;
   class DtStateVisualizerFactory;
   class DtElementDefinitionNew;
   class DtVisualizerDefinitionSet;
   class DtVisualizerDefinition;

   class DT_DLL_VRVCORE DtVisualizerSet
   {
   public:

      typedef std::vector<DtStateVisualizer*> VisualizerList;

      DtVisualizerSet(DtBaseConnection& conn, DtStateListener& listener, 
         int modelSet, bool distribute);

      virtual ~DtVisualizerSet();

      virtual void visualizeElementDefinition(const DtUnicode& elementName, 
         const DtElementDefinitionNew& def, 
         const DtVisualizerCreationSettings::VisualTypeVisualizerCreationMap& creationMap );

      virtual void visualizeElementDefinition(const DtUnicode& elementName, 
         const DtElementDefinitionNew& def);

      virtual void createVisualizersByType( int visualType );

      virtual void destroyVisualizersByType( int visualType );

      const DtElementDefinitionNew* definition() const;

      int modelSet() const;
      
      template <typename VisualizerClass>
      inline void findVisualizers(std::vector<VisualizerClass*>& visualizers);
      
      template <typename VisualizerClass>
      inline void findVisualizersByDynamicCast(std::vector<VisualizerClass*>& visualizers);

      virtual void findVisualizers(const DtVisualizerSchema&,
         VisualizerList& visualizers);

      virtual bool setVisible(bool visible, 
         DtShowHideContext::ShowHideContext context =
         DtShowHideContext::InstanceHidden);

      virtual bool isVisible() const;

      virtual bool show(DtShowHideContext::ShowHideContext);
      virtual bool hide(DtShowHideContext::ShowHideContext);

      bool isHiddenByContext(DtShowHideContext::ShowHideContext) const;
      virtual DtUniqueID uniqueID() const;

      DtSceneObjectVisualizer* sceneObjectVisualizer() const;

      virtual void setPickable( bool pickable );

      bool pickable() const;

      virtual void setSelected(bool);

      bool selected() const;

      virtual void setHasMouseCursor(bool);

      bool addVisualizer(const DtVisualizerDefinition& def);
    
      virtual void destroyAllModelVisualizers();

      virtual DtStateVisualizer::Type supportsVisualizerType() const;

      boost::signalslib::signal<void (DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName,
         DtStateVisualizer* v, DtVisualizerSet* i)>
         signal_mouseDown;
      boost::signalslib::signal<void (DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName,
         DtStateVisualizer* v, DtVisualizerSet* i)>
         signal_mouseUp;
      boost::signalslib::signal<void (DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName,
         DtStateVisualizer* v, DtVisualizerSet* i)>
         signal_mouseDblClick;

      boost::signalslib::signal< void (bool, DtVisualizerSet* vis) > signal_selectionStateChanged;

      boost::signalslib::signal< void (bool, DtVisualizerSet* vis) > signal_hasMouseCursorStateChanged;

   protected:
      void destroyAllModelVisualizersInternal();

      virtual void visualizeVisualizerDefinitionSet(const DtUnicode& elementName,
         const DtVisualizerDefinitionSet& set,
         const  DtVisualizerCreationSettings::VisualTypeVisualizerCreationMap* creationMap = nullptr);

      virtual DtStateVisualizer* createVisualizerFromDefinition(const DtVisualizerDefinition& def);

      virtual void addVisualizer(const std::string& schemaName, 
         DtStateVisualizer* visualizer);

      virtual bool suppressVisualizerCreation( const DtVisualizerDefinition* visDef,
         const  DtVisualizerCreationSettings::VisualTypeVisualizerCreationMap* 
         creationMap) const;

      virtual int findVisualType( const DtVisualizerDefinition& visDef ) const;

      virtual void setModelVisualizerVisible(const std::string& schemaName,
         bool onOff, int context);

     virtual void slot_mouseDown(
      DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
      const std::string& windowName, const std::string& channelName, DtStateVisualizer* v);
     virtual void slot_mouseUp(
      DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
      const std::string& windowName, const std::string& channelName, DtStateVisualizer* v);
     virtual void slot_mouseDblClick(
      DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
      const std::string& windowName, const std::string& channelName, DtStateVisualizer* v);

     template <typename T, typename C>
      void connectAndUpdate(boost::signalslib::signal<void (T)>& sig, void (C::*fp)(T), T val)
     {
        myConnections.manageConnection(sig.connect(boost::bind(fp, static_cast<C*>(this), _1)));
        ((C&)(*this).*fp)(val);
     }

   protected:

      const DtUnicode* chooseRandomString(const std::vector<DtUnicode>& stringList);

   protected:
      typedef boost::unordered_multimap<std::string,DtStateVisualizer* >StateVisualizerMap;

      DtBaseConnection& myBaseConnection;
      DtStateVisualizerFactory& myCachedFactory;
      DtStateListener& myStateListener;
      StateVisualizerMap myVisualizers;
      DtSignalConnectionManager myConnections;
      const DtElementDefinitionNew* myDefinition;

      bool mySelected;
      bool myHasMouseCursor;
      bool myPickable;
      bool myVisible;
      bool myDistribute;

      DtSceneObjectVisualizer* mySceneObjectVisualizer;
      typedef std::vector<DtShowHideContext::ShowHideContext> ShowHideContexts;

      ShowHideContexts myShowHideContexts;
      int myModelSet;

      std::string myVisualTypeString;
   };

   template <typename VisualizerClass>
   inline void DtVisualizerSet::findVisualizers(
      std::vector<VisualizerClass*>& visualizers)
   {
      std::pair<StateVisualizerMap::iterator,
         StateVisualizerMap::iterator> range = myVisualizers.equal_range(
         VisualizerClass::theTypeInfo().schema.name());
         
      for(; range.first != range.second; ++range.first)
      {
         VisualizerClass* instance = dynamic_cast<VisualizerClass*>(
            range.first->second);
         if(instance)
         {
            visualizers.push_back(instance);
         }
      }
   }

   template <typename VisualizerClass>
   inline void DtVisualizerSet::findVisualizersByDynamicCast(
      std::vector<VisualizerClass*>& visualizers)
   {
      StateVisualizerMap::const_iterator iter = myVisualizers.begin();

      for(; iter != myVisualizers.end(); ++iter)
      {
         VisualizerClass* instance = dynamic_cast<VisualizerClass*>(iter->second);

         if (instance)
         {
            visualizers.push_back(instance);
         }
      }
   }
}