DtKeyMap.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2008 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtKeyMap.h,v $ $Revision: 1.10 $ $State: Exp $
******************************************************************************/


#ifndef DtKeyMap_H_
#define DtKeyMap_H_

#include <vrvCore/vrvCore.h>
#include <boost/function.hpp>
#include <boost/serialization/version.hpp>

#include <vrvCore/DtKeyEvent.h>
#include <vrvCore/DtKeyState.h>
#include <makArchives/DtSerialize.h>

#include <map>
#include <list>

namespace makArchives
{
   class DtKeyMapRecord;
}

namespace makVrv
{
   
   class DT_DLL_VRVCORE DtKeyFunctionNameList
   {
   public:
      typedef std::list<std::string> KeyFunctionNameList;
      
      DtKeyFunctionNameList();

      DtKeyFunctionNameList(const KeyFunctionNameList& list);
      
      ~DtKeyFunctionNameList();
      
      DtKeyFunctionNameList& operator=( const DtKeyFunctionNameList& orig );
      
      DtKeyFunctionNameList( const DtKeyFunctionNameList& orig);
      
      void addKeyFunctionName( const std::string& functionName );
      
      void clearFunctionNameList();
      
      const KeyFunctionNameList& functionNameList() const;
      KeyFunctionNameList& functionNameList();
    
      DT_DECLARE_serialize_FUNCTIONS

   protected:

      template<class Archive>
      void _serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_MEMBER(myKeyFunctionNameList);        
      }

      KeyFunctionNameList myKeyFunctionNameList;
   };
   
   class DT_DLL_VRVCORE DtKeyFunctionSet
   {
   public:
      DtKeyFunctionSet();
      
      ~DtKeyFunctionSet();
      
      DtKeyFunctionSet& operator=( const DtKeyFunctionSet& orig );
      
      DtKeyFunctionSet( const DtKeyFunctionSet& orig );
      
      void setUnmodifiedFunction( const DtKeyFunctionNameList& func );
      
      DtKeyFunctionNameList& unmodifiedFunction();
      const DtKeyFunctionNameList& unmodifiedFunction() const;
      
      void setShiftModifiedFunction( const DtKeyFunctionNameList& func );
      
      DtKeyFunctionNameList& shiftModifiedFunction();
      const DtKeyFunctionNameList& shiftModifiedFunction() const;
      
      void setCtrlModifiedFunction( const DtKeyFunctionNameList& func );
      
      DtKeyFunctionNameList& ctrlModifiedFunction();
      const DtKeyFunctionNameList& ctrlModifiedFunction() const;
      
      void setAltModifiedFunction( const DtKeyFunctionNameList& func );
      
      DtKeyFunctionNameList& altModifiedFunction();
      const DtKeyFunctionNameList& altModifiedFunction() const;
      
      void setShiftCtrlModifiedFunction( const DtKeyFunctionNameList& func );
      
      DtKeyFunctionNameList& shiftCtrlModifiedFunction();
      const DtKeyFunctionNameList& shiftCtrlModifiedFunction() const;
      
      void setShiftAltModifiedFunction( const DtKeyFunctionNameList& func );

      DtKeyFunctionNameList& shiftAltModifiedFunction();
      const DtKeyFunctionNameList& shiftAltModifiedFunction() const;
      
      void setCtrlAltModifiedFunction( const DtKeyFunctionNameList& func );
      
      DtKeyFunctionNameList& ctrlAltModifiedFunction();
      const DtKeyFunctionNameList& ctrlAltModifiedFunction() const;
      
      void setShiftCtrlAltModifiedFunction( const DtKeyFunctionNameList& func );
      
      DtKeyFunctionNameList& shiftCtrlAltModifiedFunction();
      const DtKeyFunctionNameList& shiftCtrlAltModifiedFunction() const;
      
      DT_DECLARE_serialize_FUNCTIONS

   protected:

      template<class Archive>
      void _serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_MEMBER(myUnmodified);        
         ar & DT_SERIALIZE_MEMBER(myShiftModified);        
         ar & DT_SERIALIZE_MEMBER(myCtrlModified);        
         ar & DT_SERIALIZE_MEMBER(myAltModified);        
         ar & DT_SERIALIZE_MEMBER(myShiftCtrlModified);        
         ar & DT_SERIALIZE_MEMBER(myShiftAltModified);        
         ar & DT_SERIALIZE_MEMBER(myCtrlAltModified);        
         ar & DT_SERIALIZE_MEMBER(myShiftCtrlAltModified);        
      }
      
      DtKeyFunctionNameList myUnmodified;
      DtKeyFunctionNameList myShiftModified;
      DtKeyFunctionNameList myCtrlModified;
      DtKeyFunctionNameList myAltModified;
      DtKeyFunctionNameList myShiftCtrlModified;
      DtKeyFunctionNameList myShiftAltModified;
      DtKeyFunctionNameList myCtrlAltModified;
      DtKeyFunctionNameList myShiftCtrlAltModified;
   };

   class DT_DLL_VRVCORE DtKeyFunctionMapEntry
   {
   public:
      DtKeyFunctionMapEntry();
      
      ~DtKeyFunctionMapEntry();
      
      DtKeyFunctionMapEntry( const DtKeyFunctionMapEntry& orig );
      
      DtKeyFunctionMapEntry& operator=( const DtKeyFunctionMapEntry& orig );
      
      void setDownFunctions( const DtKeyFunctionSet& downFunctions );
      
      DtKeyFunctionSet& downFunctions();
      const DtKeyFunctionSet& downFunctions() const;
      
      void setUpFunctions( const DtKeyFunctionSet& upFunctions );
      
      DtKeyFunctionSet& upFunctions();
      const DtKeyFunctionSet& upFunctions() const;
      
      
      DT_DECLARE_serialize_FUNCTIONS

   protected:

      template<class Archive>
      void _serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_MEMBER(myDownFunctions); 
         ar & DT_SERIALIZE_MEMBER(myUpFunctions); 
      }
      
      DtKeyFunctionSet myDownFunctions;
      DtKeyFunctionSet myUpFunctions;
   };
   
   class DT_DLL_VRVCORE DtKeyMapping : public DtKeyEvent
   {
   public:
      DtKeyMapping();
      
      DtKeyMapping( const DtKeyEvent& keyEvent );
      
      DtKeyMapping( const DtKeyMapping& orig );
      DtKeyMapping& operator=( const DtKeyMapping& orig );
      
      std::string parentFunctionName() const;
      void setParentFunctionName( const std::string& parentFunctionName );
      
   protected:
      std::string myParentFunctionName;
   };
      
   class DT_DLL_VRVCORE DtReverseKeyMap
   {
   public:
      typedef std::list<DtKeyMapping*> MappedKeyList;
      
      typedef std::map<std::string, MappedKeyList*> ReverseKeyMap;
      DtReverseKeyMap();
   
      virtual ~DtReverseKeyMap();

      DtReverseKeyMap( const DtReverseKeyMap& orig );
      
      DtReverseKeyMap& operator=( const DtReverseKeyMap& orig );
           
      ReverseKeyMap& map();
      const ReverseKeyMap& map() const;
      
      void addKeyBinding( std::string functionName, DtKeyState::KeyType key,  
         DtKeyState::KeyModifier modifiers, DtKeyEvent::KeyEventType eventType );
      
      void removeKeyBinding( const std::string& functionName, DtKeyState::KeyType key,  
         DtKeyState::KeyModifier modifiers, DtKeyEvent::KeyEventType eventType );
      
      void clearMap();      
    
   protected:
      
      void copyMap( const ReverseKeyMap& orig );
   
   protected:
      ReverseKeyMap myReverseKeyMap;
   };
   
   class DtKeyMapManager;
   
   class DT_DLL_VRVCORE DtKeyMap
   {
   public:
      typedef std::map<DtKeyState::KeyType, DtKeyFunctionMapEntry*> KeyMap;
      typedef std::list<DtKeyMapping*> MappedKeyList;

   private:  
      DtKeyMap();
      
   public:
      DtKeyMap( const std::string& name, DtKeyMapManager& keyMapManager );
   
      virtual ~DtKeyMap();

      DtKeyMap( const DtKeyMap& orig );
      
      DtKeyMap& operator=( const DtKeyMap& orig );
      
      DtKeyMap* clone( const std::string& newName );
      
      const std::string& name() const { return myName; };
      
      void addKeyBinding( DtKeyState::KeyType key, const std::string& functionName, 
         DtKeyState::KeyModifier modifiers = DtKeyState::NO_MODIFIER,
         bool replace=false,
         DtKeyEvent::KeyEventType eventType = DtKeyEvent::KEY_DOWN );
         
      virtual void removeKeyBinding( DtKeyState::KeyType key, const std::string& functionName, 
         DtKeyState::KeyModifier modifiers = DtKeyState::NO_MODIFIER,
         DtKeyEvent::KeyEventType eventType = DtKeyEvent::KEY_DOWN );
         
      void addBinaryKeyBinding( DtKeyState::KeyType key, const std::string& binaryName,
          DtKeyState::KeyModifier modifiers = DtKeyState::NO_MODIFIER,
         bool replace = false );
         
      virtual void removeBinaryKeyBinding( DtKeyState::KeyType key, const std::string& functionName, 
         DtKeyState::KeyModifier modifiers = DtKeyState::NO_MODIFIER );
        
      DtKeyFunctionNameList getKeyFunctionNameList( const DtKeyEvent& keyEvent );
          
      DtKeyFunctionMapEntry* findKeyFunctions( DtKeyState::KeyType key );
      
      virtual MappedKeyList findKeyMappings( const std::string& functionName );

      virtual MappedKeyList findBinaryKeyMappings( const std::string& functionName );

      void getRecord(makArchives::DtKeyMapRecord& record) const;

      void setFromRecord(const makArchives::DtKeyMapRecord& record);
    
   protected:

      void buildReverseKeyMap();
      
      void determineParentFunctions();
      
      void processKeyFunctionSet( const DtKeyFunctionSet& functionSet, 
         DtKeyState::KeyType keyType, DtKeyEvent::KeyEventType eventType );
         
      void processKeyFunctionNameList( const DtKeyFunctionNameList& functionNames, 
         DtKeyState::KeyType keyType, DtKeyEvent::KeyEventType eventType,
         DtKeyState::KeyModifier modifiers );
         
      void processAddKeyBind( DtKeyFunctionNameList& functionList, std::string functionName, 
         DtKeyState::KeyType keyType, DtKeyEvent::KeyEventType eventType,
         DtKeyState::KeyModifier modifiers, bool replace );
      
      void processRemoveKeyBind( DtKeyFunctionNameList& functionList, std::string functionName, 
         DtKeyState::KeyType keyType, DtKeyEvent::KeyEventType eventType,
         DtKeyState::KeyModifier modifiers );
      
      void processClearKeyBind( DtKeyFunctionNameList& functionList,  
         DtKeyState::KeyType keyType, DtKeyEvent::KeyEventType eventType,
         DtKeyState::KeyModifier modifiers );

      void copyMap( const KeyMap& orig );
      
      void clearMap();      
 
   protected:

      std::string myName;
      KeyMap myKeyMap;      
      DtReverseKeyMap myReverseKeyMap;
      DtKeyMapManager& myKeyMapManager;
   };  
}

#endif