DtStateVisualizer.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtUnicode.h>
#include <boost/bind.hpp>

namespace makVrv
{
   class DtSceneObjectAgent;
   class DtBaseConnection;
   class DtMouseState;
   class DtStateListener;
   class DtVisualizerDefinition;
   class DtVisualizerSchema;

   class DT_DLL_VRVCORE DtStateVisualizer
   {

   public:
      enum Type
      {
         AllVisualizerTypes = 0,
         EntityVisualizerType = 1,
         EnvironmentalVisualizerType,
         InteractionVisualizerType,
         AggregateVisualizerType,
         IntervisibilityVisualizerType,
         TacticalSmokeVisualizerType,
         UserType = 10000
      };

      struct DT_DLL_VRVCORE TypeInfo
      {
         TypeInfo(const std::string& fname,
            const DtUnicode& sname, 
            DtStateVisualizer::Type type,
            const DtVisualizerSchema& s)
         : functionalTypeName(fname)
         , screenName(sname)
         , supportedVisualizerType(type)
         , schema(s)
         {
         }

         const std::string functionalTypeName;
         const DtUnicode screenName;
         const DtStateVisualizer::Type supportedVisualizerType;
         const DtVisualizerSchema& schema;
      };

   public:
      DtStateVisualizer(DtBaseConnection& connection, DtStateListener& listener,
         int modelSet);

      virtual ~DtStateVisualizer();

      virtual void createModelAgents() = 0;

      virtual void destroyModelAgents() = 0;

      virtual const TypeInfo& typeInfo() const = 0;

      virtual void setParent(DtStateVisualizer*);

      void setModelDefinition(const std::string& definition);

      const std::string& modelDefinition() const;

      virtual void implementVisibility(bool visible);

      virtual bool setVisible(bool visible, int context);

      virtual void initialize();

      virtual bool isVisible() const;

      virtual void setSelected(bool);
      virtual bool selected() const;

      void setName(const std::string&);
      const std::string& name() const;

      virtual void setPickable(bool);
      virtual bool pickable() const;

      virtual void setUniqueID(DtUniqueID id);

      DtUniqueID uniqueID() const
      {
         return myUniqueID;
      }

      int visualizerType() const
      {
         return myVisualizerType;
      }

      void setShowHideContext(const std::vector<int>& s)
      {
         myShowHideContexts = s;
      }

      virtual void setVisualizerDefinition(const DtVisualizerDefinition&);

      //Get the listener for this visualizer.
      inline DtStateListener& listener()
      {
         return myListener;
      }

      inline DtBaseConnection& simulation()
      {
         return mySimulation;
      }

      void setDistribute(bool b)
      {
         myDistributeFlag = b;
      }

      bool distribute() const
      {
         return myDistributeFlag;
      }

      boost::signal<void (DtStateVisualizer*, DtStateVisualizer*,
         DtStateVisualizer*)> signal_reparented;

      boost::signal<void (DtMouseState&, const DtUniqueID&, const std::string&,
         const std::string&,const std::string&, DtStateVisualizer*)>
         signal_mouseDown;
      boost::signal<void (DtMouseState&, const DtUniqueID&, const std::string&,
         const std::string&,const std::string&, DtStateVisualizer*)>
         signal_mouseUp;
      boost::signal<void (DtMouseState&, const DtUniqueID&, const std::string&,
         const std::string&,const std::string&, DtStateVisualizer*)>
         signal_mouseDblClick;

   protected:

     virtual void slot_mouseDown(DtMouseState& mouseState, 
        const std::string& displayEngineName, const std::string& windowName,
         const std::string& channelName);
     virtual void slot_mouseUp(DtMouseState& mouseState, 
        const std::string& displayEngineName, const std::string& windowName,
         const std::string& channelName);
     virtual void slot_mouseDblClick(DtMouseState& mouseState, 
        const std::string& displayEngineName, const std::string& windowName,
         const std::string& channelName);

   protected:
      virtual bool hide(int context);

      virtual bool show(int context);

      virtual bool supportsShowHideContext(int) const;

      virtual void setModelDefinitionForAgents() = 0;

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

   private:
      DtStateVisualizer();

      DtStateVisualizer( const DtStateVisualizer& );

      DtStateVisualizer& operator=( const DtStateVisualizer& );

   protected:
      
      DtBaseConnection& mySimulation;
      DtStateListener& myListener;

      bool myDistributeFlag;

      DtUniqueID myUniqueID;
      std::string myName;
      std::string myModelDefinition;
      DtSignalConnectionManager myConnections;
      int myModelSet;
      int myVisualizerType;

      std::vector<int> myShowHideContexts;
      bool mySelected;     
      bool myPickable;
      bool myVisible;          

      DtStateVisualizer* myParent;
      DtSceneObjectAgent* mySceneObjectAgent;      
   };

   class DT_DLL_VRVCORE DtStateVisualizerCreator
   {
   public:

      DtStateVisualizerCreator()
      {
      }

      virtual ~DtStateVisualizerCreator()
      {
      }

      virtual DtStateVisualizerCreator* clone() const = 0;

      virtual DtStateVisualizer* create(DtBaseConnection& simulation, 
         DtStateListener& listener, int modelSet) const = 0;

      virtual const DtStateVisualizer::TypeInfo& visualizerTypeInfo() const = 0;

      virtual const std::string& tag() = 0;

   };

   template <typename StateVisualizer>
   class DtStateVisualizerCreatorTemplate : public DtStateVisualizerCreator
   {
   public:

      DtStateVisualizerCreatorTemplate()
      {
      }

      virtual ~DtStateVisualizerCreatorTemplate()
      {
      }

      virtual DtStateVisualizerCreator* clone() const
      {
         return new DtStateVisualizerCreatorTemplate<StateVisualizer>();
      }

      virtual DtStateVisualizer* create(DtBaseConnection& simulation,
         DtStateListener& listener, int modelSet) const
      {
         return new StateVisualizer(simulation, listener, modelSet);
      }

      virtual const DtStateVisualizer::TypeInfo& visualizerTypeInfo() const
      {
         return StateVisualizer::theTypeInfo();
      }

      virtual const std::string& tag()
      {
#ifdef DtDIS
         const static std::string str("DIS");
#elif DtHLA_1516_EVOLVED
         const static std::string str("HLA1516e");
#elif DtHLA_1516
         const static std::string str("HLA1516");
#elif DtHLA
         const static std::string str("HLA13");
#else
         const static std::string str("");
#endif
         return str;
      }
   };

}