| /**************************************************************************** |
| ** |
| ** Copyright (C) 2015 The Qt Company Ltd. |
| ** Contact: http://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Gamepad module |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL3$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see http://www.qt.io/terms-conditions. For further |
| ** information use the contact form at http://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPLv3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or later as published by the Free |
| ** Software Foundation and appearing in the file LICENSE.GPL included in |
| ** the packaging of this file. Please review the following information to |
| ** ensure the GNU General Public License version 2.0 requirements will be |
| ** met: http://www.gnu.org/licenses/gpl-2.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qgamepadmanager.h" |
| |
| #include "qgamepadbackend_p.h" |
| #include "qgamepadbackendfactory_p.h" |
| |
| #include <QtCore/QLoggingCategory> |
| |
| #include <private/qobject_p.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| Q_LOGGING_CATEGORY(gp, "qt.gamepad") |
| |
| class QGamepadManagerPrivate : public QObjectPrivate |
| { |
| Q_DECLARE_PUBLIC(QGamepadManager) |
| public: |
| QGamepadManagerPrivate() |
| : gamepadBackend(nullptr) |
| { |
| loadBackend(); |
| } |
| |
| void loadBackend(); |
| |
| QGamepadBackend *gamepadBackend; |
| QMap<int, QString> connectedGamepads; |
| |
| //private slots |
| void _q_forwardGamepadConnected(int deviceId); |
| void _q_forwardGamepadNameChanged(int deviceId, const QString &name); |
| void _q_forwardGamepadDisconnected(int deviceId); |
| void _q_forwardGamepadAxisEvent(int deviceId, QGamepadManager::GamepadAxis axis, double value); |
| void _q_forwardGamepadButtonPressEvent(int deviceId, QGamepadManager::GamepadButton button, double value); |
| void _q_forwardGamepadButtonReleaseEvent(int deviceId, QGamepadManager::GamepadButton button); |
| }; |
| |
| void QGamepadManagerPrivate::_q_forwardGamepadConnected(int deviceId) |
| { |
| Q_Q(QGamepadManager); |
| connectedGamepads.insert(deviceId, QString()); |
| emit q->gamepadConnected(deviceId); |
| emit q->connectedGamepadsChanged(); |
| } |
| |
| void QGamepadManagerPrivate::_q_forwardGamepadNameChanged(int deviceId, const QString &name) |
| { |
| Q_Q(QGamepadManager); |
| connectedGamepads.insert(deviceId, name); |
| emit q->gamepadNameChanged(deviceId, name); |
| } |
| |
| void QGamepadManagerPrivate::_q_forwardGamepadDisconnected(int deviceId) |
| { |
| Q_Q(QGamepadManager); |
| connectedGamepads.remove(deviceId); |
| emit q->gamepadDisconnected(deviceId); |
| emit q->connectedGamepadsChanged(); |
| } |
| |
| void QGamepadManagerPrivate::_q_forwardGamepadAxisEvent(int deviceId, QGamepadManager::GamepadAxis axis, double value) |
| { |
| Q_Q(QGamepadManager); |
| emit q->gamepadAxisEvent(deviceId, axis, value); |
| } |
| |
| void QGamepadManagerPrivate::_q_forwardGamepadButtonPressEvent(int deviceId, QGamepadManager::GamepadButton button, double value) |
| { |
| Q_Q(QGamepadManager); |
| emit q->gamepadButtonPressEvent(deviceId, button, value); |
| } |
| |
| void QGamepadManagerPrivate::_q_forwardGamepadButtonReleaseEvent(int deviceId, QGamepadManager::GamepadButton button) |
| { |
| Q_Q(QGamepadManager); |
| emit q->gamepadButtonReleaseEvent(deviceId, button); |
| } |
| |
| void QGamepadManagerPrivate::loadBackend() |
| { |
| QStringList keys = QGamepadBackendFactory::keys(); |
| qCDebug(gp) << "Available backends:" << keys; |
| if (!keys.isEmpty()) { |
| QString requestedKey = QString::fromUtf8(qgetenv("QT_GAMEPAD")); |
| QString targetKey = keys.first(); |
| if (!requestedKey.isEmpty() && keys.contains(requestedKey)) |
| targetKey = requestedKey; |
| if (!targetKey.isEmpty()) { |
| qCDebug(gp) << "Loading backend" << targetKey; |
| gamepadBackend = QGamepadBackendFactory::create(targetKey, QStringList()); |
| } |
| } |
| |
| if (!gamepadBackend) { |
| //Use dummy backend |
| gamepadBackend = new QGamepadBackend(); |
| qCDebug(gp) << "Using dummy backend"; |
| } |
| } |
| |
| /*! |
| \class QGamepadManager |
| \inmodule QtGamepad |
| \brief Queries attached gamepads and related events. |
| |
| QGamepadManager provides a high-level interface for querying the attached |
| gamepads and events related to all of the connected devices. |
| */ |
| |
| /*! |
| * \qmltype GamepadManager |
| * \inqmlmodule QtGamepad |
| * \instantiates QGamepadManager |
| * \brief Queries attached gamepads and related events. |
| * |
| * GamepadManager QML type provides a high-level interface for |
| * querying the attached gamepads and events related to all of the |
| * connected devices. |
| */ |
| |
| /*! |
| * Constructor for QGamepadManager. |
| */ |
| |
| QGamepadManager::QGamepadManager() : |
| QObject(*new QGamepadManagerPrivate(), nullptr) |
| { |
| Q_D(QGamepadManager); |
| |
| qRegisterMetaType<QGamepadManager::GamepadButton>("QGamepadManager::GamepadButton"); |
| qRegisterMetaType<QGamepadManager::GamepadAxis>("QGamepadManager::GamepadAxis"); |
| |
| connect(d->gamepadBackend, SIGNAL(gamepadAdded(int)), this, SLOT(_q_forwardGamepadConnected(int))); |
| connect(d->gamepadBackend, SIGNAL(gamepadNamed(int, QString)), this, SLOT(_q_forwardGamepadNameChanged(int, QString))); |
| connect(d->gamepadBackend, SIGNAL(gamepadRemoved(int)), this, SLOT(_q_forwardGamepadDisconnected(int))); |
| connect(d->gamepadBackend, SIGNAL(gamepadAxisMoved(int,QGamepadManager::GamepadAxis,double)), this, SLOT(_q_forwardGamepadAxisEvent(int,QGamepadManager::GamepadAxis,double))); |
| connect(d->gamepadBackend, SIGNAL(gamepadButtonPressed(int,QGamepadManager::GamepadButton,double)), this, SLOT(_q_forwardGamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double))); |
| connect(d->gamepadBackend, SIGNAL(gamepadButtonReleased(int,QGamepadManager::GamepadButton)), this, SLOT(_q_forwardGamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton))); |
| |
| connect(d->gamepadBackend, &QGamepadBackend::buttonConfigured, this, &QGamepadManager::buttonConfigured); |
| connect(d->gamepadBackend, &QGamepadBackend::axisConfigured, this, &QGamepadManager::axisConfigured); |
| connect(d->gamepadBackend, &QGamepadBackend::configurationCanceled, this, &QGamepadManager::configurationCanceled); |
| |
| if (!d->gamepadBackend->start()) |
| qCWarning(gp) << "Failed to start gamepad backend"; |
| } |
| |
| /*! |
| * Destructor for QGamepadManager. |
| */ |
| |
| QGamepadManager::~QGamepadManager() |
| { |
| Q_D(QGamepadManager); |
| d->gamepadBackend->stop(); |
| d->gamepadBackend->deleteLater(); |
| } |
| |
| /*! |
| Returns the instance of the QGamepadManager. |
| */ |
| QGamepadManager *QGamepadManager::instance() |
| { |
| static QGamepadManager instance; |
| return &instance; |
| } |
| |
| /*! |
| Returns a boolean indicating whether the gamepad with |
| the specified \a deviceId is connected or not. |
| */ |
| bool QGamepadManager::isGamepadConnected(int deviceId) const |
| { |
| Q_D(const QGamepadManager); |
| return d->connectedGamepads.contains(deviceId); |
| } |
| |
| /*! |
| Returns the name of the gamepad identified by \a deviceId. |
| If \a deviceId does not identify a connected gamepad, returns an empty string. |
| |
| \since 5.11 |
| */ |
| QString QGamepadManager::gamepadName(int deviceId) const |
| { |
| Q_D(const QGamepadManager); |
| return d->connectedGamepads.value(deviceId); |
| } |
| |
| /*! |
| \qmlproperty var GamepadManager::connectedGamepads |
| \readonly |
| |
| Returns a list of integers containing the \l {QGamepad::}{deviceId} |
| values of the connected gamepads. |
| */ |
| |
| /*! |
| Returns a list of integers containing the \l {QGamepad::}{deviceId} |
| values of the connected gamepads. |
| */ |
| const QList<int> QGamepadManager::connectedGamepads() const |
| { |
| Q_D(const QGamepadManager); |
| return d->connectedGamepads.keys(); |
| } |
| |
| /*! |
| Returns a boolean indicating whether configuration |
| is needed for the specified \a deviceId. |
| */ |
| bool QGamepadManager::isConfigurationNeeded(int deviceId) const |
| { |
| Q_D(const QGamepadManager); |
| return d->gamepadBackend->isConfigurationNeeded(deviceId); |
| } |
| |
| /*! |
| Configures the specified \a button on the gamepad with |
| this \a deviceId. |
| Returns \c true in case of success. |
| */ |
| bool QGamepadManager::configureButton(int deviceId, QGamepadManager::GamepadButton button) |
| { |
| Q_D(QGamepadManager); |
| return d->gamepadBackend->configureButton(deviceId, button); |
| } |
| |
| /*! |
| Configures \a axis on the gamepad with the specified \a deviceId. |
| Returns \c true in case of success. |
| */ |
| bool QGamepadManager::configureAxis(int deviceId, QGamepadManager::GamepadAxis axis) |
| { |
| Q_D(QGamepadManager); |
| return d->gamepadBackend->configureAxis(deviceId, axis); |
| } |
| |
| /*! |
| Configures \a button as the cancel button on the gamepad with |
| id \a deviceId. |
| Returns \c true in case of success. |
| */ |
| bool QGamepadManager::setCancelConfigureButton(int deviceId, QGamepadManager::GamepadButton button) |
| { |
| Q_D(QGamepadManager); |
| return d->gamepadBackend->setCancelConfigureButton(deviceId, button); |
| } |
| |
| /*! |
| Resets the configuration on the gamepad with the |
| specified \a deviceId. |
| */ |
| void QGamepadManager::resetConfiguration(int deviceId) |
| { |
| Q_D(QGamepadManager); |
| d->gamepadBackend->resetConfiguration(deviceId); |
| } |
| |
| /*! |
| Sets the name of the \a file that stores the button and axis |
| configuration data. |
| */ |
| void QGamepadManager::setSettingsFile(const QString &file) |
| { |
| Q_D(QGamepadManager); |
| d->gamepadBackend->setSettingsFile(file); |
| } |
| |
| QT_END_NAMESPACE |
| |
| #include "moc_qgamepadmanager.cpp" |