KeyMappingManager.hpp

#pragma once
 
#include <QXmlStreamWriter>
#include <QtGui/QKeyEvent>
#include <QtGui/QMouseEvent>
#include <QtXml/QtXml>
 
#include <Gui/RaGui.hpp>
 
#include <Core/Utils/Index.hpp>
#include <Core/Utils/Log.hpp>
#include <Core/Utils/Observable.hpp>
#include <Core/Utils/Singleton.hpp>
#include <Core/Utils/StdOptional.hpp>
 
namespace Ra {
namespace Gui {
class RA_GUI_API KeyMappingManager : public Ra::Core::Utils::ObservableVoid
{
    RA_SINGLETON_INTERFACE( KeyMappingManager );
 
  public:
    class EventBinding
    {
      public:
        EventBinding() = default;
 
        EventBinding( Qt::MouseButtons buttons,
                      Qt::KeyboardModifiers modifiers,
                      int key,
                      bool wheel = false ) :
            m_buttons { buttons }, m_modifiers { modifiers }, m_key { key }, m_wheel { wheel } {}
 
        explicit EventBinding( Qt::MouseButtons buttons,
                               Qt::KeyboardModifiers modifiers = Qt::NoModifier ) :
            m_buttons { buttons }, m_modifiers { modifiers } {}
 
        explicit EventBinding( int key, Qt::KeyboardModifiers modifiers = Qt::NoModifier ) :
            m_modifiers { modifiers }, m_key { key } {}
 
        explicit EventBinding( bool wheel, Qt::KeyboardModifiers modifiers = Qt::NoModifier ) :
            m_modifiers { modifiers }, m_wheel { wheel } {}
 
        bool isMouseEvent() { return m_buttons != Qt::NoButton; }
        bool isWheelEvent() { return m_wheel; }
        bool isKeyEvent() { return !isMouseEvent() && !isWheelEvent(); }
        bool operator<( const EventBinding& b ) const;
 
        // public data member, since there isn't any write access getter from KeyMappingManager
        Qt::MouseButtons m_buttons { Qt::NoButton };
        Qt::KeyboardModifiers m_modifiers { Qt::NoModifier };
        // only one key
        int m_key { -1 };
        bool m_wheel { false };
    };
 
    using KeyMappingAction = Ra::Core::Utils::Index; 
    using Context          = Ra::Core::Utils::Index; 
 
    void loadConfiguration( const std::string& filename = {} );
 
    bool saveConfiguration( const std::string& filename = {} );
 
    void reloadConfiguration();
 
    std::string getLoadedFilename() { return m_file->fileName().toStdString(); }
 
    KeyMappingAction getAction( const Context& context,
                                const Qt::MouseButtons& buttons,
                                const Qt::KeyboardModifiers& modifiers,
                                int key,
                                bool wheel = false );
    KeyMappingAction
    getAction( const Context& context, const QEvent* event, int key, bool wheel = false );
    KeyMappingAction getAction( const Context& context, const EventBinding& binding );
 
    std::optional<EventBinding> getBinding( const Context& context, KeyMappingAction action );
 
    KeyMappingAction addAction( const Context& context, const std::string& actionName );
 
    KeyMappingAction
    addAction( const Context& context, const EventBinding& binding, const std::string& actionName );
 
    void setActionBinding( const Context& context,
                           const EventBinding& binding,
                           const KeyMappingAction& action );
 
    Context addContext( const std::string& contextName );
 
    Context getContext( const std::string& contextName );
 
    KeyMappingAction getAction( const Context& context, const std::string& actionName );
 
    std::string getActionName( const Context& context, const KeyMappingAction& action );
 
    std::string getContextName( const Context& context );
 
    int addListener( Observable::Observer callback );
 
    void removeListener( int callbackId );
 
    std::string getHelpText();
 
    static std::string enumNamesFromMouseButtons( const Qt::MouseButtons& buttons );
 
    static std::string enumNamesFromKeyboardModifiers( const Qt::KeyboardModifiers& modifiers );
 
    static EventBinding createEventBindingFromStrings( const std::string& buttonsString   = "",
                                                       const std::string& modifiersString = "",
                                                       const std::string& keyString       = "",
                                                       const std::string& wheelString     = "" );
 
  private:
    KeyMappingManager();
    ~KeyMappingManager();
 
    void saveNode( QXmlStreamWriter& stream, const QDomNode& domNode );
    void saveKeymap( QXmlStreamWriter& stream );
 
    void loadConfigurationInternal( const QDomDocument& domDocument );
    void loadConfigurationTagsInternal( QDomElement& node );
    KeyMappingAction loadConfigurationMappingInternal( const std::string& context,
                                                       const std::string& keyString,
                                                       const std::string& modifiersString,
                                                       const std::string& buttonsString,
                                                       const std::string& wheelString,
                                                       const std::string& actionName );
 
    static Qt::KeyboardModifiers getQtModifiersValue( const std::string& modifierString );
 
    static Qt::MouseButtons getQtMouseButtonsValue( const std::string& buttonsString );
    static int getKeyCode( const std::string& keyString );
 
    std::string m_defaultConfigFile;
    QFile* m_file;
 
    using EventBindingMap = std::map<EventBinding, KeyMappingAction>;
    using ContextNameMap  = std::map<std::string, Context>;
    using ActionNameMap   = std::map<std::string, Ra::Core::Utils::Index>;
 
    ContextNameMap m_contextNameToIndex;            
    std::vector<ActionNameMap> m_actionNameToIndex; 
    std::vector<EventBindingMap> m_bindingToAction; 
};
 
template <typename T>
class KeyMappingManageable
{
  public:
    static inline KeyMappingManager::Context getContext() { return m_keyMappingContext; }
 
    static inline void configureKeyMapping() { T::configureKeyMapping_impl(); }
 
  protected:
    T& self() { return static_cast<T&>( *this ); }
    static inline void setContext( const KeyMappingManager::Context& c ) {
        m_keyMappingContext = c;
    }
 
  private:
    static KeyMappingManager::Context m_keyMappingContext;
};
 
template <typename T>
KeyMappingManager::Context KeyMappingManageable<T>::m_keyMappingContext;
 
class RA_GUI_API KeyMappingCallbackManager
{
  public:
    using Context          = KeyMappingManager::Context;
    using KeyMappingAction = KeyMappingManager::KeyMappingAction;
    using Callback         = std::function<void( QEvent* )>;
 
    inline explicit KeyMappingCallbackManager( Context context );
 
    inline void addEventCallback( KeyMappingAction action, Callback callback );
 
    inline KeyMappingManager::KeyMappingAction
    addActionAndCallback( const std::string& actionName,
                          const KeyMappingManager::EventBinding& binding,
                          Callback callback );
 
    inline bool triggerEventCallback( QEvent* event, int key, bool wheel = false );
 
    inline bool triggerEventCallback( KeyMappingAction action, QEvent* event );
 
  private:
    std::map<KeyMappingAction, Callback> m_keymappingCallbacks;
    Context m_context;
};
 
/******************************************************************************/
/* inlines ********************************************************************/
/******************************************************************************/
 
inline bool KeyMappingManager::EventBinding::operator<( const EventBinding& b ) const {
    return ( m_buttons < b.m_buttons ) ||
           ( ( m_buttons == b.m_buttons ) && ( m_modifiers < b.m_modifiers ) ) ||
           ( ( m_buttons == b.m_buttons ) && ( m_modifiers == b.m_modifiers ) &&
             ( m_key < b.m_key ) ) ||
           ( ( m_buttons == b.m_buttons ) && ( m_modifiers == b.m_modifiers ) &&
             ( m_key == b.m_key ) && ( m_wheel < b.m_wheel ) );
}
 
inline KeyMappingCallbackManager::KeyMappingCallbackManager( Context context ) :
    m_context { context } {}
 
inline void KeyMappingCallbackManager::addEventCallback( KeyMappingAction action,
                                                         Callback callback ) {
    m_keymappingCallbacks[action] = callback;
}
 
inline KeyMappingManager::KeyMappingAction
KeyMappingCallbackManager::addActionAndCallback( const std::string& actionName,
                                                 const KeyMappingManager::EventBinding& binding,
                                                 Callback callback ) {
 
    auto mgr    = KeyMappingManager::getInstance();
    auto action = mgr->addAction( m_context, binding, actionName );
    addEventCallback( action, callback );
    return action;
}
 
inline bool KeyMappingCallbackManager::triggerEventCallback( KeyMappingAction actionIndex,
                                                             QEvent* event ) {
    auto itr = m_keymappingCallbacks.find( actionIndex );
    if ( itr == m_keymappingCallbacks.end() ) return false;
    itr->second( event );
    return true;
}
 
inline bool KeyMappingCallbackManager::triggerEventCallback( QEvent* event, int key, bool wheel ) {
    auto mgr         = KeyMappingManager::getInstance();
    auto actionIndex = mgr->getAction( m_context, event, key, wheel );
    return triggerEventCallback( actionIndex, event );
}
 
} // namespace Gui
} // namespace Ra