inputmanager.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_CORE_INPUTMANAGER_H
#define SWIFT_CORE_INPUTMANAGER_H
 
#include <functional>
#include <memory>
 
#include <QHash>
#include <QObject>
#include <QPointer>
#include <QString>
#include <QStringList>
#include <QVector>
 
#include "core/application/applicationsettings.h"
#include "core/swiftcoreexport.h"
#include "input/joystick.h"
#include "input/keyboard.h"
#include "misc/icons.h"
#include "misc/input/hotkeycombination.h"
#include "misc/input/joystickbuttonlist.h"
#include "misc/settingscache.h"
 
namespace swift::core
{
    class SWIFT_CORE_EXPORT CInputManager : public QObject
    {
        Q_OBJECT
 
    public:
        CInputManager(QObject *parent = nullptr);
 
        void registerAction(const QString &action,
                            swift::misc::CIcons::IconIndex icon = swift::misc::CIcons::StandardIconEmpty16);
 
        void registerRemoteActions(const QStringList &actions);
 
        template <typename RecvObj>
        int bind(const QString &action, RecvObj *receiver, void (RecvObj::*slotPointer)(bool))
        {
            // NOLINTBEGIN(modernize-avoid-bind)
            using namespace std::placeholders;
            auto function = std::bind(slotPointer, receiver, _1);
            return bindImpl(action, receiver, function);
            // NOLINTEND(modernize-avoid-bind)
        }
 
        template <typename Func>
        int bind(const QString &action, QObject *receiver, Func functionObject)
        {
            return bindImpl(action, receiver, functionObject);
        }
 
        void unbind(int index);
 
        void startCapture();
 
        void resetAllActions() { m_configuredActions.clear(); }
 
        QStringList allAvailableActions() const { return m_availableActions.keys(); }
 
        QMap<QString, swift::misc::CIcons::IconIndex> allAvailableActionsAndIcons() const { return m_availableActions; }
 
        void setForwarding(bool enabled) { m_actionRelayingEnabled = enabled; }
 
        void callFunctionsBy(const QString &action, bool isKeyDown, bool shouldEmit = true);
 
        void triggerKey(const swift::misc::input::CHotkeyCombination &combination, bool isPressed);
 
        void createDevices();
 
        void releaseDevices();
 
        swift::misc::input::CJoystickButtonList getAllAvailableJoystickButtons() const;
 
    signals:
        void remoteActionFromLocal(const QString &action, bool argument);
 
        void combinationSelectionChanged(const swift::misc::input::CHotkeyCombination &combination);
 
        void combinationSelectionFinished(const swift::misc::input::CHotkeyCombination &combination);
 
        void hotkeyActionRegistered(const QStringList &actions);
 
    private:
        struct BindInfo
        {
            // Using unique int index for identification because std::function does not have a operator==
            int m_index = 0;
            QString m_action;
            QPointer<QObject> m_receiver;
            std::function<void(bool)> m_function;
        };
 
        void reloadHotkeySettings();
 
        void processKeyCombinationChanged(const swift::misc::input::CHotkeyCombination &combination);
        void processButtonCombinationChanged(const swift::misc::input::CHotkeyCombination &combination);
 
        int bindImpl(const QString &action, QObject *receiver, std::function<void(bool)> function);
 
        void processCombination(const swift::misc::input::CHotkeyCombination &combination);
 
        std::unique_ptr<swift::input::IKeyboard> m_keyboard; 
        std::unique_ptr<swift::input::IJoystick> m_joystick; 
 
        QMap<QString, swift::misc::CIcons::IconIndex> m_availableActions;
        QHash<swift::misc::input::CHotkeyCombination, QString> m_configuredActions;
        QSet<QString> m_activeActions;
        QVector<BindInfo> m_boundActions;
 
        bool m_actionRelayingEnabled = false;
        bool m_captureActive = false;
        swift::misc::input::CHotkeyCombination m_lastCombination;
        swift::misc::input::CHotkeyCombination m_capturedCombination;
        swift::misc::input::CHotkeyCombination m_combinationBeforeCapture;
 
        swift::misc::CSetting<application::TActionHotkeys> m_actionHotkeys { this,
                                                                             &CInputManager::reloadHotkeySettings };
    };
} // namespace swift::core
 
#endif // SWIFT_CORE_INPUTMANAGER_H