DtKeyMapManager.h

Go to the documentation of this file.

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


#pragma once
#include <map>
#include <list>
#include <boost/function.hpp>
#include <vrvCore/DtKeyEvent.h>
#include <vrvCore/DtSettingsBackup.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <makArchives/DtKeyMapRecord.h>

namespace makVrv
{
   class DtKeyMap;
   class DtDe;
   class DtKeyFunctionNameList;
   class DtSettingsBackup;

   class DT_DLL_VRVCORE DtKeyMapManager : public DtVirtualBaseClass
   {
   public:
     
      enum FunctionCategory
      {
         Movement,
         Rotation,
         Orbit,
         Camera,
         Attachment,
         Gain,
         Rendering,
         Display,
         Miscellaneous,
         UserDefined = 100
      };
      
      typedef std::map<FunctionCategory, DtUnicode> FunctionCategories;
      typedef std::map<std::string, DtKeyMap*> KeyMapCatalog;
   
      typedef boost::function< void ()> KeyFunction;
      typedef std::map<std::string, KeyFunction> KeyFunctionMap;
      typedef std::map<std::string, std::string> BinaryFunctionNameMap;
      typedef std::map<std::string, DtSettingsBackup*> BackupMap;

      typedef std::list<std::string> CategoryList;
      
      typedef std::map<FunctionCategory, CategoryList*> CategoryMap;

      static DtKeyMapManager& instance( DtDe& de );

      virtual ~DtKeyMapManager();
     
      virtual DtKeyMap* createKeyMap( const std::string& mapName, bool silent = false );
      
      virtual DtKeyMap* cloneKeyMap( const std::string& mapName, 
         const std::string& newMapName, bool silent = false );

      virtual void destroyKeyMap( const std::string& mapName, bool silent = false );
         
      virtual DtKeyMap* findKeyMap( const std::string& mapName );

      bool saveKeyMap(const DtKeyMap& keyMap) const;

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

      DtKeyMap* loadKeyMapFromFile(const std::string& filename, bool createBackup = false);
       
      virtual void setFromRecord(const std::string& keyMap, const makArchives::DtKeyMapRecord& rec);

      virtual DtSettingsBackup* settingsBackup(const std::string& keyMap) const;

      virtual void categorizeKeyFunction( const std::string& functionName,
         FunctionCategory functionCategory );
         
      virtual void categorizeBinaryKeyFunction( const std::string& functionName,
         FunctionCategory functionCategory );
      
          
      virtual void addKeyFunction( const std::string& functionName, 
         const KeyFunction& function, FunctionCategory functionCategory,
         bool categorize = true );
     
      KeyFunction findKeyFunction( const std::string& functionName ) const;

      void removeKeyFunction( const std::string& functionName );
      
      virtual const KeyMapCatalog& keyMapCatalog() const;
      
      virtual const CategoryMap& categoryMap() const;
      virtual const CategoryMap& binaryCategoryMap() const;
      
      const BinaryFunctionNameMap& binaryDownMap() const;
      
      const BinaryFunctionNameMap& binaryUpMap() const;
                
      //
      virtual void addBinaryKeyFunction( const std::string& binaryName, 
         const std::string& keyDownFunctionName, const KeyFunction& downFunction,
         const std::string& keyUpFuntionName, const KeyFunction& upFunction, 
         FunctionCategory functionCategory );
         
      virtual std::string lookupBinaryKeyFunctionName( 
         DtKeyEvent::KeyEventType eventType, const std::string& binaryName )
         const;
      
      virtual bool processKeyEvent( const std::string& mapName, 
         const DtKeyEvent& keyEvent );
      
      virtual void activateMap( const std::string& mapName );
      
      virtual void deactivateMap( const std::string& mapName );
      
      virtual void setCurrentMap( const std::string& mapName );
      
      virtual const std::string& currentMap() const;
      
      void virtual clear();

      virtual void addFunctionCategory(FunctionCategory, DtUnicode functionCategoryName);

      virtual DtUnicode functionCategoryName(FunctionCategory) const;

      virtual const FunctionCategories& functionCategories() const;

      DtDe& de();

   protected:

      DtKeyMapManager( DtDe& de );
  
      void invokeKeyFunctions( const DtKeyFunctionNameList& funcsToUse );
         
      virtual void createBackupFor(const std::string&, const std::string& factoryFile = "");

   protected:

      DtDe& myDe;      
      std::string myCurrentMap;      
      KeyMapCatalog myKeyMapCatalog;
      KeyFunctionMap myKeyFunctionMap;
      BinaryFunctionNameMap myBinaryKeyFunctionUpMap;
      BinaryFunctionNameMap myBinaryKeyFunctionDownMap;
      CategoryMap myCategoryMap;
      CategoryMap myBinaryCategoryMap;
      BackupMap   myBackupObjects;
      FunctionCategories myFunctionCategories;
   };

   class DT_DLL_VRVCORE DtKeyMapSettingsBackup : public DtSettingsBackup
   {
   public:
      DtKeyMapSettingsBackup(DtKeyMapManager& man, const std::string& keyMap);

      virtual ~DtKeyMapSettingsBackup();

      virtual void restore(const DtSettingsBackup* from);

      virtual std::string backupClassType() const
      {
         return myKeyMap;
      }
      
     virtual std::string backupName() const
      {
         return backupClassType();
      }

      virtual DtSettingsBackup* create() const;

      virtual void write(boost::archive::xml_oarchive& ar);

      virtual void read(boost::archive::xml_iarchive& ar);

      const makArchives::DtKeyMapRecord& restoredRecord() const
      {
         return myRestoredRecord;
      }

   protected:
      std::string                   myKeyMap;
      makArchives::DtKeyMapRecord   myRestoredRecord;
      DtKeyMapManager&              myKeyMapManager;
   };
}