environmentalFacadeCollection.h

Go to the documentation of this file.

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



#pragma once

#include <vrvUtil/signalslib.h>
#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/vrfObjectFacadeInterface.h>
#include <vrfGuiCore/entityStateListenerExtensions.h>
#include <vrfGuiCore/entityFacadeCollection.h>
#include <makArchives/DtEnvironmentRecord.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 <matrix/geodeticCoord.h>

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

#include <boost/foreach.hpp>

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

class DtChangeWeatherCommand;

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtExtTacticalGraphicStateListener : public makVrv::DtTacticalGraphicStateListener, public DtCommonStateListenerExtensions
   {
   public:
      DtExtTacticalGraphicStateListener(makVrv::DtUniqueID id,
         makVrv::DtDe& de) : makVrv::DtTacticalGraphicStateListener(id),  DtCommonStateListenerExtensions(id), myDe(de) {};
      virtual ~DtExtTacticalGraphicStateListener() {};

      virtual bool isGeocentric() const;

   protected:
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUICORE DtEnvironmentalFacadeCollection : 
      public DtVrfObjectFacadeInterface
   {
   public:
      enum EnviornmentalTypes
      {
         Unknown = 0,
         Circle = 1,
         Ellipse = 2,
         Arc = 3,
         Box = 4,
         Line = 5,
         Area = 6,
         TextBox = 7,
         Wedge = 8,
         SpiderWeb = 9
      };

   public:
      DtEnvironmentalFacadeCollection(makVrv::DtDe&, int modelSet = -1, bool verticesDisabled = false);
      virtual ~DtEnvironmentalFacadeCollection();

   public:
      
      virtual void setVisible( bool visible, bool updateOffsets = true);
      virtual void setVisible(bool, int context);
      virtual bool isVisible() const;

      virtual void setUseHighestTerrainLod(bool);

      virtual void setHidden(bool b);

      virtual void setSymbolNameVisible(bool);

      virtual void setRespectPointAltitudePosition(bool);
      bool respectPointAltitudePosition() const;

      virtual void setupNodeMaskFlags();

      virtual makVrv::DtUniqueID uniqueID() const;
      virtual std::vector<makVrv::DtUniqueID> modelUniqueIDs() const;

      virtual void setUniqueID(makVrv::DtUniqueID id);

      virtual void setLabelIndicatorVisible(bool);

      virtual void setIndicatorVisible(bool);

      virtual void setAltitudeToOrigin(DtVector&) const;

      virtual void setSceneObjectId(makVrv::DtElementID id);

      virtual DtVector centerOfMass() const;

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

      virtual void setLabel(const std::string&);
      virtual std::string label() const;
      
      virtual void setFormattingData(const std::string& s);
      virtual std::string formattingData() const;

      virtual void setDropShadow(bool b);

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

      virtual void setHatLineVisible( bool visible );
      virtual void setAttachedTo(DtVrfObjectFacadeInterface* p, const DtVector& offset, const DtTaitBryan& o);

      virtual void setDictionaryToDisplay(int);
      bool dictionaryToDisplay() const { return myDictionaryToDisplay; };

      virtual DtVector origin() const;

      virtual void setMaxCeilingOffsetFromFloor(double d);
      virtual double maxCeilingOffsetFromFloor() const;
      virtual void clearMaxCeilingOffsetFromFloor();

      virtual void setWeatherCommand(const DtChangeWeatherCommand&);

      virtual void setPickable(bool b);

      virtual void setSelected(bool b);

      virtual const DtEntityType& environmentalType() const;

      virtual void setWidgetEventsEnabled(bool b);

      virtual void updateSymbolDecorationPosition();

      virtual int vertex(makVrv::DtUniqueID) const;
      virtual makVrv::DtUniqueID vertexId(int index, int modelSet = -1) const;

      virtual void setFillStyle(int);

      template <typename T_Class> int fillStyle() const
      {
         int style = myListener.fillStyle();

         ModelSetMap::const_iterator iter = myModelSetMap.begin();

         while (iter != myModelSetMap.end())
         {
            std::vector<T_Class*> visualizers;
            iter->second->findVisualizersByDynamicCast(visualizers);            
            typename std::vector<T_Class*>::iterator i = 
               visualizers.begin();
            typename std::vector<T_Class*>::iterator e = 
               visualizers.end();

            ++iter;

            for(;i != e; ++i)
            {
               if (*i)
               {
                  style = (*i)->fillStyle();
                  iter = myModelSetMap.end();
                  break;
               }
            }
         }

         return style;
      }

      virtual int fillStyle() const;

      virtual void setPenStyle(int);

      virtual int penStyle() const;

      virtual double length() const;
      virtual double width() const;

      virtual void setTopographicOffsetBetweenPoints(const DtGeodeticCoord& origin, const DtGeodeticCoord& originWithOffset, bool resetLocation = true);
      virtual void setAltitudeOffsetFromPrincipal( double offset );

      virtual void updateTopographicOffsets();

      virtual DtVector geocentricPosition(int i) const;

      virtual std::vector<DtVector> geocentricPositions() const;

      virtual void setNumberOfSpiderWebSpokes(int);

      virtual void setNumberOfSpiderWebRings(int);

      virtual void getSpiderWebInformation(double& radius, int& spokes, int& rings) const;

      template <typename T_Class> int penStyle() const
      {
         int style = myListener.penStyle();

         ModelSetMap::const_iterator iter = myModelSetMap.begin();

         while (iter != myModelSetMap.end())
         {
            std::vector<T_Class*> visualizers;
            iter->second->findVisualizersByDynamicCast(visualizers);            
            typename std::vector<T_Class*>::iterator i = 
               visualizers.begin();
            typename std::vector<T_Class*>::iterator e = 
               visualizers.end();

            ++iter;

            for(;i != e; ++i)
            {
               if (*i)
               {
                  style = (*i)->lineStipple();
                  iter = myModelSetMap.end();
                  break;
               }
            }
         }

         return style;
      }

      template <typename T_Class> void color(float &r, float& g, float& b,  float& a) const
      {
         ModelSetMap::const_iterator iter = myModelSetMap.begin();

         while (iter != myModelSetMap.end())
         {
            std::vector<T_Class*> visualizers;
            iter->second->findVisualizersByDynamicCast(visualizers);            
            typename std::vector<T_Class*>::iterator i = 
               visualizers.begin();
            typename std::vector<T_Class*>::iterator e = 
               visualizers.end();

            ++iter;

            for(;i != e; ++i)
            {
               if (*i)
               {
                  (*i)->getColor(r, g, b, a);
                  iter = myModelSetMap.end();
                  break;
               }
            }
         }
      }

      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 setFloor(double);
      virtual void clearFloorSet();
      virtual double floor() const;
      bool floorSet() const
      {
         return myFloorSet;
      }

      virtual void setCeiling(double);
      virtual double ceiling() const;
      virtual void clearCeilingSet();
      bool ceilingSet() const
      {
         return myCeilingSet;
      }


      virtual void realizeFacades();

      virtual void unrealizeFacades(bool willRecreate = false);

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

      virtual void updateGeometry();

      virtual void setSymbolDecorationPosition(const DtVector& v);

      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 setIndicatorModelDefinitions(int vertex,
         const std::string& normalTheme,
         const std::string& activeTheme,
         const std::string& selectedTheme,
         const std::string& multiSelectedTheme);

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

      virtual void setArrowStyle(int);
      virtual int arrowStyle() const;

      virtual void setArrowHeadPlacement(int);
      virtual int arrowHeadPlacement() const;

      virtual void setArrowSize(double);
      virtual double arrowSize() const;

      virtual bool fixedWidthSizing() const;

      virtual void setTopographicOffsetFromOrigin(const DtVector& geod, int i);
      const DtVector& topographicOffsetFromOrigin(int i);

      virtual void setShapeVertexVisible(bool);

      virtual void setSymbolDecorationsVisible(bool);
      virtual void setColor(int rgba);
      virtual bool colorChanged() const;
      virtual int color() const;
      virtual void setColor(float r, float g, float b, float a);
      virtual bool isPointObject() const;
      virtual const makVrv::DtUnicode& elementDefinition() const;

      virtual void setPixelLineWidth(float);
      virtual float pixelLineWidth() const;

      virtual void setPhysicalLineHeight(float);
      virtual float physicalLineHeight() const;

      virtual void setOffsetPoints(const std::vector<DtVector>&);

      virtual void setPhysicalLineWidth(float);
      virtual float physicalLineWidth() const;

      virtual bool physicalLineHeightChanged() const;
      virtual void clearPhysicalLineHeightChanged();

      virtual bool physicalLineWidthChanged() const;
      virtual void clearPhysicalLineWidthChanged();

      virtual void setDefaultCeilingHeightIfCeilingIsNotSet(double);
      double defaultCeilingHeightIfCeilingIsNotSet() { return myDefaultCeilingHeightIfCeilingIsNotSet; };

      virtual void setForce(int);

      template <typename T> void setAttached(DtVrfObjectFacadeInterface* p)
      {
         DtEntityFacadeCollection* efc = dynamic_cast<DtEntityFacadeCollection*>(p);
         ModelSetMap::iterator iter = myModelSetMap.begin();

         while (iter != myModelSetMap.end())
         {
            std::vector<T*> visualizers;
            iter->second->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 (efc)
                  {
                     (*i)->setAttached(efc->modelSetMap()[iter->first]->uniqueID());
                  }
                  else
                  {
                     (*i)->setAttached(0);
                  }
               }
            }

            ++iter;
         }
      }

      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, bool sel);
      virtual void selectVertex(int index, bool sel);
      virtual void clearSelectedVertices();

      virtual DtGeodeticCoord locationFromTopographicOffsetLocation(const DtGeodeticCoord& origin, int index) const;

      makVrv::DtBaseConnection& baseConnection() const;

      virtual void setElementDefinition(const makVrv::DtUnicode& definition);
      virtual void setElementDefinition(const DtEntityType&, bool preparseOnly = false);

      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, bool andUpdateOffset = true);
      virtual int addPoint(const DtVector&, int index = -1, bool resetLocation = true, bool notifyOfAddedPoint = false);
      virtual void setPoints(const std::vector<DtVector>&, bool updateOffsets = true, bool notifyOfAddedPoint = false);
      const std::vector<DtVector>& points() const;
      std::vector<DtVector> geocentricPoints() const;
      virtual void removePoint(int);
      DtGeodeticCoord geodeticPosition(int) const;
      virtual void updateOffsets();

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

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

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

      int numVertices() const;

      const DtExtTacticalGraphicStateListener& listener() const
      {
         return myListener;
      }

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

      int selectedPoint() const;

      virtual void setIconScale(float);

      virtual bool appearanceChanged() const;

      virtual double calculatedHeading() const;

      virtual DtVector geometricCenter() const;

      virtual DtGeodeticCoord geodeticCenter() const;

      virtual std::vector<DtVector> rotatePointsTo(const std::vector<DtVector>&, double heading) const;

      virtual void setTopographicOrientation(const DtTaitBryan&);
      virtual void setLocalOrientation(const DtTaitBryan&);

      virtual void updateSymbolRotation(const DtTaitBryan&);

      virtual void updateSymbolRotation(double);

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

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

      virtual bool isBox() const;

      virtual bool isTextBox() const;

      virtual bool isLine() const;

      virtual bool isArea() const;

      virtual bool isUnknown() const;

      virtual bool isCircle() const;

      virtual bool isWedge() const;

      virtual bool isSpiderWeb() const;

      virtual bool isEllipse() const;

      virtual bool isArc() const;

      virtual void setIsClosedFigure(bool);
      virtual bool isClosedFigure() const;

      DtExtTacticalGraphicStateListener& listener()
      {
         return myListener;
      }

      virtual void updateHeading();

      void setNeedsUpdate(bool b) { myNeedsGeometryUpdate = b; };

      virtual void mergeExtendedData(const std::map<std::string, std::string>&);

      virtual void setExtendedData(const std::map<std::string, std::string>&);
      virtual std::map<std::string, std::string> extendedData() const;

      virtual void setExtendedLabels(const std::map<int, DtString>&);
      virtual std::map<int, DtString> extendedLabels() const;

      virtual void updateOffset(const DtVector& position, int i, bool force = false);
      virtual void setAltitudeForPoint(const DtVector& v, int index);

      virtual DtVector clampToGround( const DtVector& localPosition, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes, int clampFlag = -1 ) const;
      virtual DtGeodeticCoord clampToGround( const DtGeodeticCoord& localPosition, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes, int clampFlag = -1 ) const;

      virtual DtVector setFloorToVertex(const DtVector&) const;

      virtual int clampTypeFor(int index) const;

      boost::signals2::signal<void (DtEnvironmentalFacadeCollection*)> signal_locationsChanged;
      boost::signals2::signal<void (DtEnvironmentalFacadeCollection*, int, bool)> signal_vertexSelected;
      boost::signals2::signal<void (DtEnvironmentalFacadeCollection*)> signal_geometryUpdated;

   protected:
      virtual void setSpiderWebRadius(double);

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

      virtual void clearVertices(makVrv::DtEnvironmentalVisualizerSet*);

      virtual void finalizeSetup();

      virtual void updateSpiderWebRadius();

   protected:
      makVrv::DtUnicode myElementDefinition;

      float myDefaultColor[4];

      makVrv::DtBaseConnection* myConnection;

      DtExtTacticalGraphicStateListener       myListener;
      std::vector<double> myAltitudeAboveTerrain;
      std::vector<double> myAltitudeAboveSeaLevel;
      std::vector<int> myClampType;

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

      double myDefaultWidth;
      int mySelectedPoint;

      std::vector<DtVector> myTopographicOffsetFromOrigin;
      bool myAlwaysRecalculateGeometry;

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

      char myEnvironmentType;

      int myColor;
      bool myColorChanged;
      bool myDisplayVertices;
      bool myShowVertices;
      bool myAppearanceChanged;
      bool myIsClosedFigure;
      bool myHatLinesVisible;
      bool myShapeVerticesDisabled;

      double myFloor;
      bool myFloorSet;

      bool myCeilingSet;
      bool myPhysicalLineWidthChanged;
      bool myPhysicalLineHeightChanged;

      int myFillStyle;

      double myArrowSize;
      bool myIsVolumetric;
      bool myAttached;
      bool myNeedsGeometryUpdate;
      bool myUseHighestTerrainLOD;
      bool mySetupNodeMaskFlags;
      bool myNeedsNodeMaskUpdate;
      bool myWidgetEventsEnabled;
      bool myPickable;
      bool myIndicatorsVisible;
      bool mySymbolDecorationsVisible;
      double myDefaultCeilingHeightIfCeilingIsNotSet;

      int myDictionaryToDisplay;
      bool myRespectPointAltitudePosition;

      double myMaxCeilingOffsetFromFloor;
      bool myMaxCeilingOffsetFromFloorSet;
      boost::signalslib::connection myFinalizeConnection;
   };

   class DT_DLL_VRFGUICORE DtEnvironmentalFacadeCollectionCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtEnvironmentalFacadeCollectionCreator(makVrv::DtDe& de);
      virtual ~DtEnvironmentalFacadeCollectionCreator();

      static DtEnvironmentalFacadeCollectionCreator& instance(makVrv::DtDe& de);
      static void registerInstance(makVrv::DtDe&, DtEnvironmentalFacadeCollectionCreator*);

      virtual DtEnvironmentalFacadeCollection* create(int modelSet = -1, bool verticesDisabled = false);

   protected:
      makVrv::DtDe& myDe;
   };
}