include/vrfGuiCore/DtEnvironmentalFacadeCollection.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 <vrvCore/DtTacticalGraphicStateListener.h>
#include <vrvCore/DtBaseConnection.h>
#include <vrvCore/DtModelSetRealizationManager.h>
#include <vrvCore/DtSharedModelSetSettings.h>
#include <vrvCore/DtVisualizerSet.h>
#include <vrvCore/DtEnvironmentalVisualizerSet.h>
#include <vrvCore/DtEnvironmentalIndicatorVisualizer.h>
#include <vrvCore/DtEnvironmentalVertexVisualizer.h>
#include <vrvVrl/DtForceManager.h>

#include <vlpi/entityType.h>
#include <matrix/geodCoord.h>

#include <string>
#include <map>
#include <vector>

#include <boost/foreach.hpp>

class DtEntityType;

namespace makVrv
{
   class DtEnvironmentalVisualizerSet;
   class DtDe;
   class DtVisualDefinitionSet;
}

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtEnvironmentalFacadeCollection : 
      public DtVrfObjectFacadeInterface
   {
   public:
      DtEnvironmentalFacadeCollection(makVrv::DtDe&, int modelSet = -1);
      virtual ~DtEnvironmentalFacadeCollection();

   public:
      
      virtual void setVisible( bool visible );
      
      virtual void setHidden(bool b);

      makVrv::DtUniqueID uniqueID() const;

      virtual void setUniqueID(makVrv::DtUniqueID id);

      virtual void setIndicatorVisible(bool);

      virtual void setSceneObjectId(makVrv::DtElementID id);

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

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

      virtual void setHatLineVisible( bool visible );

      virtual DtVector origin() const;

      virtual void setPickable(bool b);

      virtual void setSelected(bool b);

      virtual void setWidgetEventsEnabled(bool b);

      template <typename T> void setWidgetEventsEnabled(makVrv::DtEnvironmentalVisualizerSet* v, bool b)
      {
         std::vector<T> visualizers;
         v->findVisualizers(visualizers);            
         typename std::vector<T>::iterator iter = visualizers.begin();

         while (iter != visualizers.end())
         {
            (*iter)->setWidgetEventsEnabled(b);
            ++iter;
         }
      }

      virtual void realizeFacades();

      virtual void unrealizeFacades();

      virtual void setProjected(bool);
      virtual bool projected() const;

      virtual void updateGeometry();

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

      virtual void setIndicatorModelDefinitions(
         const std::string& normalTheme,
         const std::string& activeTheme,
         const std::string& selectedTheme,
         const std::string& multiSelectedTheme);

      virtual void setLockUpdates(bool);
      bool updatesLocked() const;

      virtual void setAlwaysRecalculateGeometry(bool);
      bool alwaysRecalculateGeometry() const;

      virtual void setLocationOffsetFromFirst(const DtGeodeticCoord& geod, int i);
      const DtGeodeticCoord& locationOffsetFromFirst(int i);

      virtual void setShapeVertexVisible(bool);
      virtual void setSymbolDecorationsVisible(bool);
      virtual void setColor(int rgba);
      virtual void setColor(float r, float g, float b, float a);

      virtual void setLineWidth(float);

      virtual double lineWidth() const;

      virtual void setForce(int);

      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);
            }
         }
      }
         
      virtual void setVertexSelected(makVrv::DtUniqueID id, bool sel);

      makVrv::DtBaseConnection& baseConnection() const;

      virtual void setElementDefinition(const makVrv::DtUnicode& definition);
      virtual void setElementDefinition(const DtEntityType&);
      DtEntityType environmentalType() const;

      makVrv::DtUniqueID uniqueIDForModelSet(int i) const;
      int positionOfVertex(makVrv::DtUniqueID) const;
      DtVector position(int index) const;

      virtual double altitudeForAltitudeType(int) const;

      virtual void setOrigin(const DtVector&);
      virtual void setOrigin(const DtGeodeticCoord&);

      virtual void setPoint(const DtVector&, int);
      virtual int addPoint(const DtVector&, int index = -1);
      virtual void setPoints(const std::vector<DtVector>&);
      const std::vector<DtVector>& points() const;
      virtual void removePoint(int);
      DtGeodeticCoord geodeticPosition(int) const;

      virtual DtVector reviseLocation(int index, const DtVector& v);

      void setAltitudeAboveTerrain(int, double);
      double altitudeAboveTerrain(int = -1) const;

      void setAltitudeAboveSeaLevel(int, double);
      double altitudeAboveSeaLevel(int = -1) const;

      int numVertices() const;

      const makVrv::DtTacticalGraphicStateListener& listener() const
      {
         return myListener;
      }

      virtual void selectPoint(int);
      virtual void clearSelectedPoint();

      int selectedPoint() const;

      virtual void setIconScale(float);

      virtual void setOrientation(const DtTaitBryan&);

      virtual void setAltitudeAboveSeaLevel(double);
      virtual void setAltitudeAboveTerrain(double);

      virtual DtVector localLocation(const DtGeodeticCoord& geodLocation) const;
      virtual DtVector localLocation() const;

      virtual bool isCircle() const;

      virtual bool isEllipse() const;

      makVrv::DtTacticalGraphicStateListener& listener()
      {
         return myListener;
      }

   protected:
      DtEntityType                           myEntityType;
      makVrv::DtUnicode myElementDefinition;

      float myDefaultColor[4];

      makVrv::DtBaseConnection* myConnection;

      makVrv::DtTacticalGraphicStateListener       myListener;
      std::vector<double> myAltitudeAboveTerrain;
      std::vector<double> myAltitudeAboveSeaLevel;

      typedef std::map<int, makVrv::DtEnvironmentalVisualizerSet*> ModelSetMap;
      ModelSetMap myModelSetMap;
      double myDefaultWidth;
      int mySelectedPoint;

      std::vector<DtGeodeticCoord> myLocationOffsetFromFirst;
      bool myAlwaysRecalculateGeometry;

      typedef std::vector<makVrv::DtUniqueID> UniqueIDs;
      std::map<int, UniqueIDs> myIds;

      char myIsCircular;
   };
}