DtObserverModeManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtBaseSettingsManager.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <makArchives/DtObserverModesRecord.h>
#include <vrvCore/DtObserverMode.h>

#include <string>
#include <map>

namespace makVrv
{
   class DtObserverModeManager;

   class DT_DLL_VRVCORE DtObserverModesSettingsBackup 
      : public DtRecordSettingsBackup< DtBaseSettingsManager<makArchives::DtObserverModesRecord>, 
                                       makArchives::DtObserverModesRecord >
   {
   public:

      DtObserverModesSettingsBackup(DtDe& de, DtObserverModeManager* parent, 
         const std::string& name, const std::string& displayName );

      virtual ~DtObserverModesSettingsBackup();

      virtual void restoreSelected( const DtSettingsBackup* );

      virtual int currentSelectedObserverMode() const;
      virtual void setCurrentSelectedObserverMode( int modeKey );

   protected:
      int myCurrentSelectedObserverMode;
   };

   class DtDe;
   class DtStringKeyConverter;

   class DT_DLL_VRVCORE DtObserverModeManager
      : public DtBaseSettingsManager<makArchives::DtObserverModesRecord>
   {
   public:

      typedef std::map<int, DtObserverMode> ObserverModes;

   public:

      static DtObserverModeManager& instance( DtDe& de );

      virtual ~DtObserverModeManager();

      const ObserverModes& observerModes() const;

      int numberOfObserverModes() const;

      virtual int createObserverMode( const std::string& stringKey,
         const std::string& displayName );

      virtual int cloneObserverMode(  int modeKeyOrig, const std::string& newStringKey,
         const std::string& newDisplayName );

      virtual int createModeKey( const std::string& stringKey );

      virtual void removeObserverMode( int mode );

      int lookupObserverModeKey( const std::string& stringKey ) const;

      const std::string* findObserverModeStringKey( int modeKey )  const;

      bool getObserverModeById( int modeKey, DtObserverMode& result ) const;

      bool getObserverModeByName( const std::string& observerModeName,
         DtObserverMode& result );

      std::string name( int modeKey ) const;

      void setName( int modeKey, const std::string& name );

      int modelSet( int modeKey ) const;

      void setModelSet( int modeKey, int modelSet );

      std::string keyMap( int modeKey ) const;

      void setKeyMap( int modeKey, const std::string& keyMap );

      void setIs2D( int modeKey, bool trueOrFalse );

      bool is2D( int modeKey ) const;

      void setSensor(int modeKey, const std::string& sensorName);

      std::string sensor( int modeKey ) const;

      void setGainPrecision( int modeKey, int precision );

      int gainPrecision( int modeKey ) const;

      void setModelScaleFactor( int modeKey, double modelScaleFactor );

      double modelScaleFactor( int modeKey ) const;

      void setModelScaleType( int modeKey, const std::string& modelScaleType );

      const std::string& modelScaleType( int modeKey ) const;

      void setMaxModelScaleFactor( int modeKey, double maxModelScaleFactor );

      double maxModelScaleFactor( int modeKey ) const;

      void setMaxLinearModelScaleFactor( int modeKey, double maxLinearModelScaleFactor );

      double maxLinearModelScaleFactor( int modeKey ) const;

      void setOrbitSpeedGain( int modeKey, int gain );

      int orbitSpeedGain( int modeKey ) const;

      void setLinearScaledSpeedGain( int modeKey, int gain ); 

      int linearScaledSpeedGain( int modeKey ) const;

      void setLinearUnscaledSpeedGain( int modeKey, int gain );

      int linearUnscaledSpeedGain( int modeKey ) const;

      void setRotationSpeedGain( int modeKey, int gain );

      int rotationSpeedGain( int modeKey ) const;

      void setSpeedScalingMode( int modeKey, 
         DtObserverObject::SpeedScalingMode mode );
      DtObserverObject::SpeedScalingMode speedScalingMode( int modeKey ) const;

      void setSpeedScalingMslModeOffset( int modeKey, double offset );
      double speedScalingMslModeOffset( int modeKey ) const;

      void setCameraShakeEnabled( int modeKey, bool enabled );
      bool cameraShakeEnabled( int modeKey ) const;

      void setCameraShakeIntensity( int modeKey, double intensity );
      double cameraShakeIntensity( int modeKey ) const;

      void setLodScaleCenterEnabled(int modeKey, bool enabled);
      bool lodScaleCenterEnabled(int modeKey) const;

      void setLodScaleCenterMagMinLimit(int modeKey, double limit);
      double lodScaleCenterMagMinLimit(int modeKey) const;

      void setObserverSetting( int modeKey, int settingKey, bool val );

      bool observerSetting( int modeKey, int settingKey ) const;


      virtual void loadDefaultSettings( bool loadOnlyDefaultSettings );

      virtual void loadDefaultSettings( bool loadOnlyDefaultSettings, bool merge );

      using DtBaseSettingsManager<makArchives::DtObserverModesRecord>::importSettings;

      virtual void importSettings( const std::string& filepath, bool merge );

      virtual void exportObserverMode( int modeKey,
         const std::string& filepath ) const;

      virtual void setFromRecord( const makArchives::DtObserverModesRecord& record );

      virtual void setFromRecord( const makArchives::DtObserverModesRecord& record,
         bool merge );

      virtual void setObserverModeFromRecord( const makArchives::DtObserverModesRecord& record,
         int modeKey );

      virtual void getRecord( makArchives::DtObserverModesRecord& record ) const;

      virtual DtObserverModesSettingsBackup* observerModeSettingsBackup();

   public:

      boost::signal<void (int)> observerModeKeyMapChanged;

      boost::signal<void (int)> observerModeModelSetChanged;

      // \brief signal that the indicated observer mode's dimension changed
      boost::signal<void (int)> observerModeIs2DChanged;

      boost::signal<void (int)> observerModeNameChanged;

      boost::signal<void (int)> observerModeSensorChanged;

      boost::signal<void (int, int,bool)> observerModeSettingChanged;

      boost::signal<void (int)> observerModeGainPrecisionChanged;

      boost::signal<void (int)> observerModeOrbitSpeedGainChanged;

      boost::signal<void (int)> observerModeRotationSpeedGainChanged;

      boost::signal<void (int)> observerModeLinearScaledSpeedGainChanged;

      boost::signal<void (int)> observerModeLinearUnscaledSpeedGainChanged;

      boost::signal<void (int)> observerModeModelScaleFactorChanged;

      boost::signal<void (int)> observerModeModelScaleTypeChanged;

      boost::signal<void (int)> observerModeMaxModelScaleFactorChanged;

      boost::signal<void (int)> observerModeMaxLinearModelScaleFactorChanged;

      boost::signal<void (int)> observerModeSpeedScalingModeChanged;

      boost::signal<void (int)> observerModeSpeedScalingMslModeOffsetChanged;

      boost::signal<void (int)> observerModeCameraShakeEnabledChanged;

      boost::signal<void (int)> observerModeCameraShakeIntensityChanged;

      boost::signal<void(int)> observerModeLodScaleCenterEnabledChanged;

      boost::signal<void(int)> observerModeLodScaleCenterMagMinLimitChanged;

      boost::signal<void (int)> observerModeAdded;

      boost::signal<void (int)> observerModeToBeRemoved;

   protected:

      template <typename ManagerClass>
      friend ManagerClass& defaultManagerInstanceFunction( DtDe&, bool );

      template <typename ManagerClass>
      friend void defaultManagerRegisterInstanceFunction( DtDe&, ManagerClass* );

      friend class DtObserverModeManagerCreator;

      DtObserverModeManager( DtDe& );

      DtObserverMode* getObserverModePtr( int modeKey );

      const DtObserverMode* getObserverModeConstPtr( int modeKey ) const;

      virtual void addObserverMode( const DtObserverMode& mode );

      virtual void clear();

      virtual void initializeBackup();

      virtual void slot_wireframeModeChanged(bool onOrOff);


   protected:

      typedef std::map<std::string,int> ObserverModesMap;

      DtStringKeyConverter* myStringKeyConverter;

      // The map of visual modes (from id to DtObserverMode)
      ObserverModes myObserverModes;

      // map from name to id
      ObserverModesMap myObserverModesMap;

      DtSignalConnectionManager mySignalConnections;

   };


   class DT_DLL_VRVCORE DtObserverModeManagerCreator : public DtVirtualBaseClass
   {
   public:

      DtObserverModeManagerCreator();

      virtual ~DtObserverModeManagerCreator();

      static DtObserverModeManagerCreator& instance( DtDe& de );

      virtual DtObserverModeManager* create( DtDe& );

   };

}