DtInputDriver.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtInputDriver.h,v $ $Revision: 1.80 $ $State: Exp $
******************************************************************************/


#pragma once 
#include <vrvCore/vrvCore.h>
#include <makArchives/DtObserverStateRecord.h>
#include <vrvCore/DtElementEntry.h>
#include <vrvCore/DtDriver.h>
#include <vrvCore/DtKeyMapManager.h>
#include <vrvCore/DtViewStateProcessor.h>
#include <vrvCore/DtKeyEvent.h>
#include <vrvUtil/DtObserverConfiguration.h> 
#include <boost/signal.hpp>

#include <string>
#include <map>
#include <vector>
#include <list>

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

   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 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 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, 
         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, 
         std::string binaryName, 
         DtKeyState::KeyModifier modifiers = DtKeyState::NO_MODIFIER,
         bool replace = false );

      virtual void realizeConfiguration(
         const DtInputDriverConfiguration& 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;      

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

      DtObserver* currentObserver() const;

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


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

      virtual void toggleTerrainScaling();

      virtual void incrementTerrainScaleFactor();

      virtual void decrementTerrainScaleFactor();

      virtual void toggleEntityLabels();

      virtual void toggleTacticalGraphics();

      virtual void toggleEntityHatLines();

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

      virtual void toggleTacticalGraphicsHatMode();

      virtual void togglePropTransparencySelected();

      void resetObservers(DtUniqueID id);

      void setAllowObserverReset(bool allow);

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

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

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

   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 );

   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;           

      DtObserver* myCurrentObserver;     

      bool myAllowResetFlag;

      bool myIsTerrainContextEnabled;

      DtChannel* myCurrentChannel;

      DtKeyMapManager& myCachedKeyMapManager;

      bool mySyncingObservers;
   };

   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);

   };

}