include/vrfGuiCore/DtEntityFacadeCollection.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/DtVrfObjectFacadeInterface.h>
#include <vrfGuiCore/DtEntityStateListenerExtensions.h>

#include <vrvCore/DtBaseConnection.h>
#include <vrvCore/DtAggregateStateListener.h>
#include <vrvCore/DtSharedModelSetSettings.h>
#include <vrvCore/DtVisualizerSet.h>
#include <vrvUtil/DtUnicode.h>
#include <vrvVrl/DtForceManager.h>

#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>

#include <vlpi/entityType.h>

#include <string>
#include <map>

class DtEntityType;

namespace makVrv
{
   class DtVisualDefinitionSet;
   class DtAgentManagerInterface;
   class DtDe;
   class DtBaseConnection;
}

namespace makVrf
{
   class MyStateVisualizer : public makVrv::DtStateVisualizer
   {
   public:
      MyStateVisualizer(makVrv::DtBaseConnection& connection, makVrv::DtStateListener& listener,
         int modelSet) : makVrv::DtStateVisualizer(connection, listener, modelSet) {};

      int modelSet() const { return myModelSet; };
   };

   class DT_DLL_VRFGUICORE DtExtAggregateStateListener : public makVrv::DtAggregateStateListener, public DtEntityStateListenerExtensions
   {
   public:
      DtExtAggregateStateListener(makVrv::DtUniqueID id) : makVrv::DtAggregateStateListener(id),  DtEntityStateListenerExtensions(id) {};
      virtual ~DtExtAggregateStateListener() {};
   };

   class DT_DLL_VRFGUICORE DtEntityFacadeCollection : public DtVrfObjectFacadeInterface
   {
   public:
      typedef std::map<int, makVrv::DtVisualizerSet*> ModelSetMap;

   public:
      DtEntityFacadeCollection(makVrv::DtDe&, int modelSet = -1);
      virtual ~DtEntityFacadeCollection();

   public:

      virtual void visualize(const makVrv::DtUnicode& type, 
         const makVrv::DtSharedModelSetSettings::ModelSetVisualizedMap& sets);            

      const ModelSetMap& modelSetMap() const
      {
         return myModelSetMap;
      }

      ModelSetMap& modelSetMap()
      {
         return myModelSetMap;
      }

      virtual void setOrientation(const DtTaitBryan& orientation);
      
      virtual void setOrigin(const DtVector& v);
      virtual void setOrigin(const DtGeodeticCoord& v);

      virtual void setOriginAndSeaLevel(const DtVector& v);
      virtual void setOriginAndSeaLevel(const DtGeodeticCoord& v);

      virtual void setForceId(int);
      int forceId() const;

      virtual makVrv::DtBaseConnection& baseConnection() const;
      
      void setHatLineVisible( bool visible );

      virtual void setVisible(bool b);

      virtual void setPickable(bool b);

      virtual void setSelected(bool b);

      virtual void setOverlayName(const std::string&);
      virtual std::string overlayName() const;

      virtual void setIndicatorVisible(bool b);

      virtual void setUniqueID(makVrv::DtUniqueID);
      makVrv::DtUniqueID uniqueID() const;

      virtual void setWidgetEventsEnabled(bool b);

      virtual void setGroundClamping(bool b);

      virtual void setSymbolDecorationOffset(double x, double y);

      virtual void setAutoEnableGroundClamping(bool b);

      virtual void realizeFacades();

      virtual void unrealizeFacades();

      virtual bool hasProjectedModel(int modelSet) const;

      virtual void setElementDefinition(const makVrv::DtUnicode& elementName);      
      
      virtual const makVrv::DtUnicode& elementDefinition() const;

      virtual void setElementDefinition(const DtEntityType&);

      void setSmoothingEnabled(bool enabled);

      void setMotionModel(const std::string&);

      virtual void setHeadingIndicatorVisible(bool);

      virtual void setHeadingIndicatorSize(float l);

      //virtual bool visualDefinitionSetFor(const std::string& type, makVrv::DtVisualDefinitionSet&, int, bool& isAggregate);

      virtual DtVector position() const;

      virtual makVrv::DtUniqueID uniqueIDForModelSet(int set) const;

      virtual void setEffectsVisible(bool);

      virtual void setAltitudeAboveTerrain(double d);

      virtual void setAltitudeAboveSeaLevel(double d);

      template <typename T> bool hasVisualizer(makVrv::DtVisualizerSet* s) const
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);
         
         return (visualizers.size() != 0);
      }

      virtual void setIconScale(float);
      template <typename T> void setIconScale(makVrv::DtVisualizerSet* s, float scale)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setIconScale(scale);
            }
         }
      }

      virtual void setEntityExtents(const DtVector& volume, const DtVector& offset);

      virtual bool hasBoundingVolumes() const;

      virtual void setEntityExtentsVisible(bool, int modelSet = -1);
      template <typename T> void setEntityExtentsVisible(makVrv::DtVisualizerSet* s, bool b, int modelSet = -1)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               if ((modelSet == -1) || (modelSet == ((MyStateVisualizer*)(*i))->modelSet()))
               {
                  (*i)->setVisible(b);
               }
            }
         }
      }

      template <typename T> void setScale(makVrv::DtVisualizerSet* s, float scale)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setScale(scale);
            }
         }
      }

      template <typename T> void setForceColor(makVrv::DtVisualizerSet* s, makVrv::DtForceManager::RGBAColor color)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setForceColor(color.R, color.G, color.B, color.A);
            }
         }
      }

      template <typename T> void setColor(makVrv::DtVisualizerSet* s, makVrv::DtForceManager::RGBAColor color)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setColor(color.R, color.G, color.B, color.A);
            }
         }
      }

      virtual void setDisplayName( const std::string& displayName );

      virtual void setSymbolDecorationsVisible(bool);

      virtual bool isAggregate() const
      {
         return myIsAggregate;
      }

   protected:
      DtEntityType                           myEntityType;
      makVrv::DtUnicode                      myElementDefinition;

      makVrv::DtBaseConnection* myConnection;

      DtExtAggregateStateListener         myListener;
      ModelSetMap myModelSetMap;

      std::string myOverlay;
      bool myIsAggregate;
   };
}