DtInputDriver.h

Go to the documentation of this file.

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


#pragma once 
#include <makArchives/DtObserverStateRecord.h>
#include <vrvCore/DtDriver.h>
#include <vrvCore/DtKeyMapManager.h>
#include <vrvCore/DtViewStateProcessor.h>
#include <vrvUtil/DtObserverConfiguration.h> 

#include <string>
#include <vector>

namespace makVrv
{
   class DtAgentManager;
   class DtChannel;
   class DtChannelManager;
   class DtDe;
   class DtEventProcessorInterface;
   class DtInputDriverConfiguration;
   class DtKeyAndMouseEventListener;
   class DtKeyMap;
   class DtKeyMapManager;
   class DtMouseEvent;
   class DtPinchGesture;
   class DtObserver;
   class DtObserverController;
   class DtChannelConfiguration;
   class DtObserverAnimator;
   class DtObserverViewsManager;
   class DtMouseHideProcessor;

   class DT_DLL_VRVCORE DtInputDriver : public DtDriver
   {
   public:
      typedef std::list<DtEventProcessorInterface*> EventProcessorList;

      typedef std::map<std::string, makArchives::DtObserverStateRecord> ObserverStateMap;

      typedef std::map<std::string, DtObserverConfiguration> ObserverConfigurationMap;

      DtInputDriver(DtAgentManager& agentManager,
         const std::string& instanceName);

      virtual ~DtInputDriver();

      virtual bool onStart();

      virtual bool onStop();

      virtual bool onTick();

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

      virtual bool processKeyEvent(const DtKeyEvent& keyEvent,
         DtChannel* channel);

      virtual bool processMouseEvent(const DtMouseEvent& mouseEvent,
         DtChannel* channel);

      virtual bool processPinchGesture(const DtPinchGesture& pinchGesture,
         DtChannel* channel);

      // hides the mouse if it hasn't moved for some period of time
      virtual void setMouseHideProccessorEnabled(bool enabled);

      virtual void hideMouse(DtChannel* channel, float mouseX, float mouseY);

      virtual bool isMouseHidden() const;

      virtual void showMouse(DtChannel* channel);

      virtual void centerMouse(DtChannel* channel);

      virtual void setMousePosition(DtChannel* channel, float x, float y);

      virtual void clearState();

      DtChannel* currentChannel() const;
      virtual DtChannel* findCurrentChannel() const;

      virtual void addEventProcessorToFront(DtEventProcessorInterface* epi);

      virtual void addEventProcessorToBack(DtEventProcessorInterface* epi);

      virtual EventProcessorList& eventProcessorList();

      virtual DtEventProcessorInterface* findEventProcessor(
         const std::string& className);

      virtual void removeEventProcessor(DtEventProcessorInterface* epi);

      bool saveKeyMapToFile(const DtKeyMap& keyMap, const std::string& filename) const;

      DtKeyMap* loadKeyMapFromFile(const std::string& filename, bool createBackup = false);

      //
      void setKeyMap(const std::string& mapName);

      const std::string& keyMap() const;

      DtKeyMap* createKeyMap(const std::string& mapName);

      DtKeyMap* findKeyMap(const std::string& mapName);

      void addKeyBinding(DtKeyMap* map, DtKeyState::KeyType key,
         const std::string& functionName,
         DtKeyState::KeyModifier modifiers = DtKeyState::NO_MODIFIER,
         bool replace = false,
         DtKeyEvent::KeyEventType eventType = DtKeyEvent::KEY_DOWN);

      void addBinaryKeyBinding(DtKeyMap* map, DtKeyState::KeyType key,
         const std::string& binaryName,
         DtKeyState::KeyModifier modifiers = DtKeyState::NO_MODIFIER,
         bool replace = false);

      virtual void realizeConfiguration(
         const DtConfiguration& configuration);

      virtual void realizeObserverConfiguration(
         const DtObserverConfiguration& configuration);

      const ObserverConfigurationMap& observerConfigurations() const;

      void addObserverConfiguration(const DtObserverConfiguration& config);

      void addObserverState(const std::string& observerName,
         const makArchives::DtObserverStateRecord& stateRecord);

      void initializeObserver(DtObserver* observer,
         const makArchives::DtObserverStateRecord& stateRecord);

      //-----

      virtual void addObserver(DtObserver* observer);

      virtual void removeObserver(DtObserver* observer);

      virtual void removeObserver(const std::string& name);

      virtual std::vector<DtObserver*> observers() const;

      virtual DtObserver* findObserverByName(const std::string& name);
      virtual const DtObserver* findObserverByName(const std::string& name) const;

      virtual void setCurrentObserver(const std::string& observerName);

      DtObserver* currentObserver() const;
      virtual DtObserver* findCurrentObserver() const;

      void setTerrainContextEnabled(bool enabled);
      bool terrainContextEnabled() const;


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

      virtual void toggleTerrainScaling();

      virtual void toggleWireframe();

      virtual void toggleSimulationTimePaused();

      virtual void incrementTerrainScaleFactor();

      virtual void decrementTerrainScaleFactor();

      virtual void toggleEntityLabels();

      virtual void toggleEmbarkedEntityLabels();

      virtual void toggleRotateEntitySymbols();

      virtual void toggleTacticalGraphics();

      virtual void toggleEntityHatLines();

      virtual void toggleTacticalGraphicsHatLines();
      virtual void toggleEntityHatMode();

      virtual void toggleTacticalGraphicsHatMode();

      virtual void toggleShowActiveTacticalGraphics();

      virtual void togglePropTransparencySelected();

      virtual void toggleViewControl();

      void resetObservers(DtUniqueID id);

      virtual void setAllowObserverReset(bool allow);
      virtual bool allowObserverReset();

      virtual void setObserverRestoreOnSlaveConnectEnabled(bool enable);
      virtual bool isObserverRestoreOnSlaveConnectEnabled();

      void saveObservers(const std::string& filename);

      void loadObservers(const std::string& filename, bool force = false);

      DtElementEntry::ObjectType typeFromId(const DtUniqueID& id);

      virtual void animateObserver(DtObserverAnimator* newAnimator);

      virtual void removeAnimatorFromObserver(DtObserver *observer);

      virtual void takeScreenCapture();

      virtual void toggleDeveloperDebugUI();

      const DtObserverViewsManager& observerViewsManager() const;
      DtObserverViewsManager& observerViewsManager();

      bool getLastMouseEventPosition(int& x, int& y);

      DtChannel* lastMouseEventChannel() const;

   protected:

      void setCurrentObserver(DtObserver* observer);

      virtual void initializeKeyMapManager(const std::string& defaultKeyMap);
      virtual void bindFunctions();
      virtual void createMaps();

      virtual void loadMaps(bool loadFromFactory = false);

      typedef std::map<std::string, DtObserver*> ObserversMap;

      void removeObserver(ObserversMap& observers, DtObserver* observer);
      void removeObserver(ObserversMap& observers, const std::string& name);

      void destroyObservers();

      bool setCurrentObserverFromChannel(const DtChannel& channel);

      void slot_channelCreated(DtChannelManager* channelManager, DtChannel* channel);
      void slot_channelDestroyed(DtChannelManager* channelManager, DtChannel* channel);
      void slot_channelConfigurationModified(const std::string& deName,
         const std::string& winName, const std::string& oldChannelName,
         const DtChannelConfiguration& config);
      void slot_attachedToChanged(DtObserver* observer);


      void createRequiredObservers(const std::string& engineName);

      virtual void slot_displayEngineAdded(const DtDeRecord& igRecord);

      std::string restoreObserversPart1();

      void restoreObserversPart2(const std::string& filename);

      virtual void slot_displayEngineRealized(const std::string&,
         const std::string& engineName);

      bool trimmedMatch(DtObserver* observer);

      bool showObserverNameWarning();

      void setShowObserverNameWarning(bool warn);

   private:
      DtInputDriver(const DtInputDriver&);

      DtInputDriver& operator=(const DtInputDriver&);

   protected:
      DtDe& myDe;

      EventProcessorList myEventProcessors;

      ObserversMap myObservers;
      DtObserverController* myObserverController;

      ObserverConfigurationMap myObserverConfigurations;
      ObserverStateMap myObserverStates;

      std::string myClassName;
      DtKeyAndMouseEventListener* myKeyAndMouseEventListener;

      int myLastMouseEventPositionX;
      int myLastMouseEventPositionY;
      DtChannel* myLastMouseEventChannel;

      DtObserver* myCurrentObserver;

      bool myAllowResetFlag;

      bool myIsTerrainContextEnabled;

      DtChannel* myCurrentChannel;

      DtKeyMapManager& myCachedKeyMapManager;

      bool mySyncingObservers;
      std::list<DtObserverAnimator*> myAnimatingObservers;
      
      // Pointer to the DtObserverViewsManager
      DtObserverViewsManager* myObserverViewsManager;

      // Object used to hide mouse (if enabled) when mouse hasn't moved for some period
      // of time
      DtMouseHideProcessor* myMouseHideProcessor;

      bool myObserverRestoreOnSlaveConnectEnabled;

      bool myShowObserverNameWarning;
   };

   class DT_DLL_VRVCORE DtInputDriverCreator : public DtVirtualBaseClass
   {
   public:

      DtInputDriverCreator();

      virtual ~DtInputDriverCreator();

      static DtInputDriverCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtInputDriverCreator* creator);

      virtual DtInputDriver* create(DtAgentManager& sm);

   };

}