DtVrlinkDriver.h

Go to the documentation of this file.

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


#pragma once

#include <vrvVrl/vrvVrl.h>
#include <vrvCore/DtDriver.h>
#include <vrvUtil/DtLockedBufferedQueue.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtViewStateProcessor.h>
#include <vlutil/vlThread.h>

#include <vlutil/vlRunnable.h>

#include <boost/function.hpp>
#include <boost/signal.hpp>

class DtThread;
class DtEntityType;

namespace makVrv
{
   class DtAsynchronousEventQueue;
   class DtAsynchronousAgentManager;   
   class DtConnection;
   class DtEntityTypeMapper;
   class DtObserver;
   class DtSelectionManager;
   class DtMouseState;

   class DT_DLL_VRVVRL DtVrlinkDriver : public DtDriver, 
      protected DtRunnable
   {
   public:

      DtVrlinkDriver(DtAgentManager& agentManager, 
         const std::string& uniqueName, const std::string& className);

      virtual ~DtVrlinkDriver();

      virtual const std::string& className() const;

      virtual bool observersPublished() const;

      virtual void setObserversPublished(bool isPublished);

      virtual bool overrideGlobalViewControl() const;

      virtual void setOverrideGlobalViewControl(bool enabled);

      virtual bool viewControlEnabled() const;

      virtual void setLocalViewControlEnabled(bool enabled);

      virtual bool localViewControlEnabled() const;

      virtual void setConnectionFrameTime( double frameTime );

      virtual double connectionFrameTime() const;

      void setUseTopoForFlatEarthVectorConversion( bool flag );
      bool useTopoForFlatEarthVectorConversion() const;


      virtual void queueDriverFunction(const boost::function<void ()>& function);

      virtual void queueConnectionFunction(const boost::function<void ()>& function);

      bool useThreadFlag() const
      {
         return myUseThreadFlag;
      }

      DtConnection* connection()
      {
         return myConnection;
      }

      boost::signal<void (DtConnection*)> signal_simulationCreated;

      boost::signal<void (DtConnection*)> signal_simulationAboutToBeDestroyed;
      
   protected:
   
      virtual DtConnection* createConnection() = 0;

      virtual bool onStart();

      virtual bool onStop();

      virtual void run();

      void startPublishingObservers();

      void stopPublishingObservers();

      virtual bool onTick();

      void startThread();

      void stopThread();
      
      void setConnectionState( bool state );

      virtual void slot_displayEngineAdded( const DtDeRecord& igRecord );

      virtual void slot_globalViewControlEnabledSet( bool );


      virtual void connectToDynamicSignals();

      virtual void disconnectFromDynamicSignals();

      virtual void slot_onViewChanged(
         DtViewStateProcessor::ObserverAction& action);

      virtual void slot_onCurrentSelectionChanged( 
         const DtSelectionManager::IdSet& selected,
         const DtSelectionManager::IdSet& deselected);

      virtual void slot_onVertexSelected( const DtUniqueID& selected,
         const DtUniqueID& parentOfSelected);

      virtual void slot_onVertexDeselected( const DtUniqueID& deselected,
         const DtUniqueID& parentOfDeselected);

      virtual void slot_onEntityInfoToggled( 
         const DtSelectionManager::IdSet& entityIds);

      virtual void slot_onEntityIndicatorMouseDown(DtMouseState& mouseState,
         const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName);
      
      virtual void slot_onEntityIndicatorMouseUp(DtMouseState& mouseState,
         const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName);
      
      virtual void slot_onEntityIndicatorMouseDblClick(DtMouseState& mouseState,
         const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName);

      virtual void slot_onTacticalGraphicIndicatorMouseDown(
         DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, 
         const std::string& channelName);
      
      virtual void slot_onTacticalGraphicIndicatorMouseUp(
         DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, 
         const std::string& channelName);
      
      virtual void slot_onTacticalGraphicIndicatorMouseDblClick(
         DtMouseState& mouseState, const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, 
         const std::string& channelName);

      virtual void slot_onCoordinateSystemChanged( 
         const std::string& coordinateSystem, 
         const std::string& coordinateParameters );
    
      virtual void toggleEntitySelected(const DtUniqueID& id);

      virtual void performObserverAction(
         const DtViewStateProcessor::ObserverAction& action);


      virtual void slot_onObserverDestroyed(DtObserver* observer);

      virtual void slot_onObserverCreated(DtObserver* observer);

      virtual void startPublishingObserver( DtObserver* observer );

      virtual void stopPublishingObserver( DtObserver* observer );

      virtual void updateObservers();

      virtual void slot_pause();

      virtual void slot_resume();

      void indicatorMouseDown(DtMouseState& mouseState,
         const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName);

      void indicatorMouseUp(DtMouseState& mouseState,
         const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName);

      void indicatorMouseDblClick(DtMouseState& mouseState,
         const DtUniqueID& id, const std::string& displayEngineName,
         const std::string& windowName, const std::string& channelName);

      typedef DtLockedBufferedQueue<boost::function<void ()> > FunctionCallQueue;
      typedef std::vector<boost::function<void ()> > FunctionCallList;

      enum FunctionType {Create, Update, Destroy};

      virtual void runFunctionQueue(FunctionCallQueue& queue);

   protected:

      //Main thread variables.
      std::string myClassName;

      //Cross thread variables.  They are used between the two threads for
      //communication.
      bool myUseThreadFlag;
      DtThreadStartSP myStart;
      DtThread* myThread;
      
      FunctionCallQueue myConnectionThreadFunctions;
      FunctionCallQueue myDriverThreadFunctions;
      DtAsynchronousAgentManager* myAsynchronousInterface;

      DtConnection* myConnection;
      DtAsynchronousEventQueue* myAsynchronousEventQueue;
      bool myConnectionState;

      DtSignalConnectionManager myDynamicSignals;

      double myObserverUpdateTimeInterval;
      double myLastObserverUpdateTime;
      double myLastSimTime; // only used when single threaded
      bool myObserversPublished;
      bool myLocalViewControlEnabled;
      bool myGlobalViewControlEnabled;
      bool myOverrideGlobalViewControlEnabled;
      bool myUseTopoForFlatEarthVectorConversion;
      double myConnectionFrameTime;

      DtSelectionManager& mySelectionManager;

   };
}