DtChannelKeywordCompass.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2021 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#pragma once 
 
#include <vrvCore/vrvCore.h>
#include <vrvCore/DtChannelKeywordObject.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <string>

namespace makVrv 
{ 
   class DtDe;
   class DtChannelConfiguration;
   class DtWindowConfiguration;
   class DtChannelCompassAgent;
   class DtObserver;
   class DtObserverObject;
   class DtInputDriver;

   class DT_DLL_VRVCORE DtChannelKeywordCompass : public DtChannelKeywordObject
   {
   public:

      friend class DtChannelKeywordLargeCompassCreator;
      friend class DtChannelKeywordSmallCompassCreator;

      virtual ~DtChannelKeywordCompass();

      DtChannelKeywordCompass() = delete;

      DtChannelKeywordCompass(const DtChannelKeywordCompass &other) = delete;

      DtChannelKeywordCompass &operator=(const DtChannelKeywordCompass &other) = delete;
   
      virtual void channelNameChanged( const std::string& displayName, 
         const std::string& windowName,  const std::string& channelName );

      virtual void channelConfigurationChanged( 
         const DtChannelConfiguration& config );

      virtual void windowConfigurationChanged( 
         const DtWindowConfiguration& config ) {}

      DtChannelCompassAgent* compassAgent();

   protected:
        
      // Slots for responding to observer-related signals

      // Called when an observer is created, so that we can connect to an observer that
      // didn't exist when the compass itself was created
      virtual void slot_observerCreated( DtInputDriver*, DtObserver* observer );
      
      // Called when an observer is about to be destroyed, so we can disconnect from the 
      // observer mode changed signal and set myObserver to Null
      virtual void slot_observerToBeDestroyed( DtInputDriver*, DtObserver* observer );
      
      // Called when an observer's observer mode changes, so we can determine if we need
      // to create or destroy a compass
      virtual void slot_observerModeChanged( DtObserver* observer, int newMode );
      
      // Called when an observer mode's setting changes; if its the mode our observer is
      // using and the setting is DisplayCompass, we may need to create or destroy
      // a compass
      virtual void slot_observerModeSettingChanged( int mode, int setting );

      // Called when an observer projection setting changes; if its the mode our observer is
      // using, we may need to create or destroy a compass
      virtual void slot_observerProjectionChanged(DtObserverObject* observerObject, bool is2D);
      
      // Helper methods

      // Set myObserver to the specified observer and connect to the observerModeChanged
      // signal
      virtual void connectToObserver( DtObserver* observer );

      // Look up the observer by name, cache the observer name, and call connectToObserver
      // with the found observer
      virtual void connectToObserver( const std::string& observerName );

      // Disconnect from the current observer's observerModeChanged signal, delete the
      // the compass agent if it exists, and set myObserver and myCompassAgent
      // to Null
      virtual void disconnectFromObserver();

      // This function looks up the display compass observer setting value and creates 
      // or destroys a compass as needed
      virtual void updateCompassState();

   protected:

      DtChannelKeywordCompass( DtDe& de, const std::string& keyword, 
         const std::string& displayName, const std::string& windowName, 
         const DtChannelConfiguration& channelConfig, bool is2D ); 
         
   protected:

      DtChannelCompassAgent* myCompassAgent;
      std::string myObserverName;
      DtObserver* myObserver;
      std::string myKeyword;
      std::string myDisplayName;
      std::string myWindowName;
      std::string myChannelName;
      DtSignalConnectionManager myConnections;
      bool myIs2D;
   }; 

   class DT_DLL_VRVCORE DtChannelKeywordLargeCompassCreator : public DtChannelKeywordObjectCreator
   {
   public:
      DtChannelKeywordLargeCompassCreator();

      virtual ~DtChannelKeywordLargeCompassCreator();

      DtChannelKeywordLargeCompassCreator(const DtChannelKeywordLargeCompassCreator &other) = delete;

      DtChannelKeywordLargeCompassCreator &operator=(const DtChannelKeywordLargeCompassCreator &other) = delete;

      virtual DtChannelKeywordObject* createChannelKeywordObject(DtDe& de, 
         const std::string& displayName, const std::string& windowName, 
         const DtChannelConfiguration& channelConfig );
         
   public:
      static std::string keyword();
      
   protected:
      std::string myKeyword;
   };
   

   class DT_DLL_VRVCORE DtChannelKeywordSmallCompassCreator : public DtChannelKeywordObjectCreator
   {
   public:
      DtChannelKeywordSmallCompassCreator();

      virtual ~DtChannelKeywordSmallCompassCreator();

      DtChannelKeywordSmallCompassCreator(const DtChannelKeywordSmallCompassCreator &other) = delete;

      DtChannelKeywordSmallCompassCreator &operator=(const DtChannelKeywordSmallCompassCreator &other) = delete;

      virtual DtChannelKeywordObject* createChannelKeywordObject(DtDe& de, 
         const std::string& displayName, const std::string& windowName, 
         const DtChannelConfiguration& channelConfig );
         
   public:
      static std::string keyword();
      
   protected:
      std::string myKeyword;
   };

}