DtOsgOverlaySegmentedLineModel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtOverlaySegmentedLineModel.h>
#include <vrvCore/DtTacticalGraphicUtilities.h>
#include <vrvOsg/DtOverlaySegmentedLineModelInstance.h>
#include <vrvCore/DtOverlayScreenIntervaledTextInstance.h>

#include <vrvUtil/signalslib.h>

namespace makVrv
{
   class DtChannelManager;
   class DtChannel;
   class DtChannelConfiguration;
   class DtModelDefinition;
   class DtCoordinateSystem;
   class DtDe;

   class DT_DLL_VRVOSG DtOsgOverlaySegmentedLineModel : public DtOverlaySegmentedLineModel
   {
   public:
      DtOsgOverlaySegmentedLineModel(DtDe& de, DtUniqueID id);

      ~DtOsgOverlaySegmentedLineModel();
      
      virtual void setPosition( int vtx, const DtVector& position );

      virtual void removePosition( int vtx );

      virtual void setOrientation( int vtx, const DtTaitBryan& orientation );

      // @{
      virtual void setNorthUnit(DtSharedDisplayUnitsSettings::NorthUnits unit);
      virtual DtSharedDisplayUnitsSettings::NorthUnits northUnit() const;
      // @}
      
      // @{
      virtual void setPosition(const DtVector& position);
      virtual DtVector position() const;
      // @}

      virtual void setColor( float r, float g, float b, float a );

      virtual void setWidth( float width );

      virtual void setStipplePattern( unsigned int pattern, int repeatFactor );

      virtual void setStyleSegments(const std::vector<double>& segmentPercentages);

      virtual void setSegmentColor(unsigned int segmentIndex,
         float r, float g, float b, float a);

      virtual void setSegmentLightningStyle(unsigned int segmentIndex,
         bool enableLightningStyle);

      virtual void setSegmentStartArrow(unsigned int segmentIndex,
         bool enableArrow);

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

      virtual void setGroup( int );

      virtual void setSegmentEndArrow(unsigned int segmentIndex,
         bool enableArrow);

      virtual void setSegmentStipplePattern(unsigned int segmentIndex,
         unsigned int stipplePattern, int repeatFactor);

      virtual void setSegmentWidth(unsigned int segmentIndex,
         double width);

      virtual void setArrowSize(double);

      virtual void setLineStyle(int);

      virtual void setArrowStyle(int);

      virtual void setSegmentStartColor( unsigned int segmentIndex, float r, 
         float g, float b, float a );

      virtual void setSegmentEndColor( unsigned int segmentIndex, float r, 
         float g, float b, float a );

      virtual void setEventsEnabled( bool );

      virtual void setEventWidth(float width);

      // @name Inherited DtModel methods
      // @{

      virtual void addToScene( const DtUniqueID& sceneObjectId, DtModelSetId modelSet, int visualizerType );

      virtual void removeFromScene();

      virtual void setModelDefinition( const std::string& str );

      virtual void setVisible( bool isVisible );

      virtual void setIsSupportModel(bool isSupport);

      // @}

      virtual void update();

      virtual void needsUpdate();

      virtual void setFixedWidthSizing(bool);

      // @{
      virtual void setIsMeasurementTextRenderingEnabled(bool isMeasurementTextRenderingEnabled);
      virtual bool isMeasurementTextRenderingEnabled() const;
      // @}

      // @{

      virtual void setIsScreenIntervaledTextRenderingEnabled(bool);

      virtual void setScreenIntervaledTextPrefix(const std::string& prefixString);

      virtual void setScreenIntervaledTextPostfix(const std::string& postfixString);

      virtual void setScreenIntervaledTextCollection(const DtOverlayScreenIntervaledTextInstance::DtScreenIntervaledTextCollection&);

      virtual void setScreenIntervaledTextInterval(int intervalInScreenSpaceCM);

      virtual void setScreenIntervaledTextFont(const std::string& fontFile, float fontPointSize);

      virtual void setScreenIntervaledTextColor(float r, float g, float b, float a);

      virtual void setScreenIntervaledTextBackgroundColor(float r, float g, float b, float a);
      // @}

   protected:
      virtual void moveInstancesFromChannelSpecific();

      virtual void moveInstancesToChannelSpecific();

      virtual void slot_channelCreated( DtChannel* channel);

      virtual void slot_channelDestroyed( DtChannelManager* channelManager, DtChannel* channel);

      virtual void slot_channelConfigurationModified(const std::string& deName, 
         const std::string& winName, const std::string& oldChannelName,
         const DtChannelConfiguration& config);

      virtual void slot_displayUnitUnitChanged(const DtUnicode& displayUnitCollectionName,
         const DtUnicode& displayUnitName, unsigned int newUnit, unsigned int oldUnit);

      virtual void slot_displayUnitDecimalsChanged(const DtUnicode& displayUnitCollectionName,
         const DtUnicode& displayUnitName, unsigned int newDecimals, unsigned int oldDecimals);

      virtual void slot_suppressMagneticNorthNotationEnabledChanged(bool isEnabled);

      virtual void setupInstanceWithCurrentValues(DtOverlaySegmentedLineModelInstance*, DtOverlayScreenIntervaledTextInstance*);

      virtual void initializeSettings();

   protected:
      struct ChannelInstance
      {
         DtOverlaySegmentedLineModelInstance* channelLineModelInstance = nullptr;
         DtOverlayScreenIntervaledTextInstance* screenTextInstance = nullptr;
      };

      DtUniqueID mySceneObjectId;
      bool myEventsEnabled;
      float myEventWidth;
      bool myNeedsUpdate;

      bool myChannelSpecificMode;

      bool myIsScreenIntervaledTextRenderingEnabled;
      DtOverlayScreenIntervaledTextInstance::DtScreenIntervaledTextCollection myScreenIntervaledTextCollection;
      int myScreenIntervaledTextIntervalInScreenSpaceCM;

      std::string myScreenIntervaledTextPrefixString;
      std::string myScreenIntervaledTextPostfixString;

      std::string myScreenIntervaledTextFontFile;
      float myScreenIntervaledTextFontPointSize;

      float myScreenIntervaledTextFontColor[4];
      float myScreenIntervaledTextBackgroundColor[4];

      typedef std::map<DtChannel*, ChannelInstance> ChannelInstances;
      ChannelInstances myChannelInstances;

      DtSignalConnectionManager myDisplayUnitConnections;
      DtSharedDisplayUnitsSettings::NorthUnits myNorthToUse;
      DtVector myPosition;

      std::vector<DtVector> myPoints;
      double myArrowSize;
      vrvTacticalGraphicUtilities::ArrowStyle myArrowStyle;
      vrvTacticalGraphicUtilities::LineStyle myLineStyle;
      DtOverlaySegmentedLineModelInstance::SegmentAttributesVector mySegmentInformation;
      std::string myModelDefinition;
      float myColor[4];
      unsigned int myStipplePattern;
      int myRepeatFactor;
      float myWidth;
      bool myFixedWidthSizing;
      int myGroup;
      bool myIsMeasurementTextRenderingEnabled;
      
      vrvSignalsLib::connection myModelInstanceChangedConnection;
      vrvSignalsLib::connection myChannelCreatedConnection;
      vrvSignalsLib::connection myChannelToBeDestroyedConnection;
      vrvSignalsLib::connection myChannelConfigurationModifiedConnection;
      vrvSignalsLib::connection myPostUpdateConnection;
   };
}