From 8a3579ea871ac20878492ce032a7b03c8c0b8c58 Mon Sep 17 00:00:00 2001 From: Andy Nichols Date: Mon, 30 Jan 2017 13:41:01 +0100 Subject: PImplize the public exports QGamepad, QGamepadManager, and QGamepadKeyNavigation needed private implementations. Change-Id: I592933f2b8a3101f0a7b9eeaf789e6ac8e2bc15b Reviewed-by: Laszlo Agocs --- src/gamepad/qgamepad.cpp | 667 +++++++++++++++++++--------------- src/gamepad/qgamepad.h | 46 +-- src/gamepad/qgamepadkeynavigation.cpp | 331 ++++++++++------- src/gamepad/qgamepadkeynavigation.h | 17 +- src/gamepad/qgamepadmanager.cpp | 169 +++++---- src/gamepad/qgamepadmanager.h | 26 +- 6 files changed, 699 insertions(+), 557 deletions(-) diff --git a/src/gamepad/qgamepad.cpp b/src/gamepad/qgamepad.cpp index 9a759cb..9c10267 100644 --- a/src/gamepad/qgamepad.cpp +++ b/src/gamepad/qgamepad.cpp @@ -36,8 +36,315 @@ #include "qgamepad.h" +#include + QT_BEGIN_NAMESPACE +class QGamepadPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QGamepad) + +public: + QGamepadPrivate(int deviceId) + : deviceId(deviceId) + , connected(false) + , axisLeftX(0.0) + , axisLeftY(0.0) + , axisRightX(0.0) + , axisRightY(0.0) + , buttonA(false) + , buttonB(false) + , buttonX(false) + , buttonY(false) + , buttonL1(false) + , buttonR1(false) + , buttonL2(0.0) + , buttonR2(0.0) + , buttonSelect(false) + , buttonStart(false) + , buttonL3(false) + , buttonR3(false) + , buttonUp(false) + , buttonDown(false) + , buttonLeft(false) + , buttonRight(false) + , buttonCenter(false) + , buttonGuide(false) + { + } + + QGamepadManager *gamepadManager; + + int deviceId; + bool connected; + QString name; + double axisLeftX; + double axisLeftY; + double axisRightX; + double axisRightY; + bool buttonA; + bool buttonB; + bool buttonX; + bool buttonY; + bool buttonL1; + bool buttonR1; + double buttonL2; + double buttonR2; + bool buttonSelect; + bool buttonStart; + bool buttonL3; + bool buttonR3; + bool buttonUp; + bool buttonDown; + bool buttonLeft; + bool buttonRight; + bool buttonCenter; + bool buttonGuide; + + void setConnected(bool isConnected); + + void _q_handleGamepadConnected(int id); + void _q_handleGamepadDisconnected(int id); + void _q_handleGamepadAxisEvent(int id, QGamepadManager::GamepadAxis axis, double value); + void _q_handleGamepadButtonPressEvent(int id, QGamepadManager::GamepadButton button, double value); + void _q_handleGamepadButtonReleaseEvent(int id, QGamepadManager::GamepadButton button); +}; + +void QGamepadPrivate::setConnected(bool isConnected) +{ + Q_Q(QGamepad); + if (connected != isConnected) { + connected = isConnected; + emit q->connectedChanged(connected); + } +} + +/*! + * \internal + */\ +void QGamepadPrivate::_q_handleGamepadConnected(int id) +{ + if (id == deviceId) { + setConnected(true); + } +} + +/*! + * \internal + */\ +void QGamepadPrivate::_q_handleGamepadDisconnected(int id) +{ + if (id == deviceId) { + setConnected(false); + } +} + +/*! + * \internal + */\ +void QGamepadPrivate::_q_handleGamepadAxisEvent(int id, QGamepadManager::GamepadAxis axis, double value) +{ + Q_Q(QGamepad); + if (id != deviceId) + return; + + switch (axis) { + case QGamepadManager::AxisLeftX: + axisLeftX = value; + emit q->axisLeftXChanged(value); + break; + case QGamepadManager::AxisLeftY: + axisLeftY = value; + emit q->axisLeftYChanged(value); + break; + case QGamepadManager::AxisRightX: + axisRightX = value; + emit q->axisRightXChanged(value); + break; + case QGamepadManager::AxisRightY: + axisRightY = value; + emit q->axisRightYChanged(value); + break; + default: + break; + } +} + +/*! + * \internal + */\ +void QGamepadPrivate::_q_handleGamepadButtonPressEvent(int id, QGamepadManager::GamepadButton button, double value) +{ + Q_Q(QGamepad); + if (id != deviceId) + return; + + switch (button) { + case QGamepadManager::ButtonA: + buttonA = true; + emit q->buttonAChanged(true); + break; + case QGamepadManager::ButtonB: + buttonB = true; + emit q->buttonBChanged(true); + break; + case QGamepadManager::ButtonX: + buttonX = true; + emit q->buttonXChanged(true); + break; + case QGamepadManager::ButtonY: + buttonY = true; + emit q->buttonYChanged(true); + break; + case QGamepadManager::ButtonL1: + buttonL1 = true; + emit q->buttonL1Changed(true); + break; + case QGamepadManager::ButtonR1: + buttonR1 = true; + emit q->buttonR1Changed(true); + break; + case QGamepadManager::ButtonL2: + buttonL2 = value; + emit q->buttonL2Changed(value); + break; + case QGamepadManager::ButtonR2: + buttonR2 = value; + emit q->buttonR2Changed(value); + break; + case QGamepadManager::ButtonL3: + buttonL3 = true; + emit q->buttonL3Changed(true); + break; + case QGamepadManager::ButtonR3: + buttonR3 = true; + emit q->buttonR3Changed(true); + break; + case QGamepadManager::ButtonSelect: + buttonSelect = true; + emit q->buttonSelectChanged(true); + break; + case QGamepadManager::ButtonStart: + buttonStart = true; + emit q->buttonStartChanged(true); + break; + case QGamepadManager::ButtonUp: + buttonUp = true; + emit q->buttonUpChanged(true); + break; + case QGamepadManager::ButtonDown: + buttonDown = true; + emit q->buttonDownChanged(true); + break; + case QGamepadManager::ButtonLeft: + buttonLeft = true; + emit q->buttonLeftChanged(true); + break; + case QGamepadManager::ButtonRight: + buttonRight = true; + emit q->buttonRightChanged(true); + break; + case QGamepadManager::ButtonCenter: + buttonCenter = true; + emit q->buttonCenterChanged(true); + break; + case QGamepadManager::ButtonGuide: + buttonGuide = true; + emit q->buttonGuideChanged(true); + break; + default: + break; + } + +} + +/*! + * \internal + */\ +void QGamepadPrivate::_q_handleGamepadButtonReleaseEvent(int id, QGamepadManager::GamepadButton button) +{ + Q_Q(QGamepad); + if (id != deviceId) + return; + + switch (button) { + case QGamepadManager::ButtonA: + buttonA = false; + emit q->buttonAChanged(false); + break; + case QGamepadManager::ButtonB: + buttonB = false; + emit q->buttonBChanged(false); + break; + case QGamepadManager::ButtonX: + buttonX = false; + emit q->buttonXChanged(false); + break; + case QGamepadManager::ButtonY: + buttonY = false; + emit q->buttonYChanged(false); + break; + case QGamepadManager::ButtonL1: + buttonL1 = false; + emit q->buttonL1Changed(false); + break; + case QGamepadManager::ButtonR1: + buttonR1 = false; + emit q->buttonR1Changed(false); + break; + case QGamepadManager::ButtonL2: + buttonL2 = 0.0; + emit q->buttonL2Changed(0.0); + break; + case QGamepadManager::ButtonR2: + buttonR2 = 0.0; + emit q->buttonR2Changed(0.0); + break; + case QGamepadManager::ButtonL3: + buttonL3 = false; + emit q->buttonL3Changed(false); + break; + case QGamepadManager::ButtonR3: + buttonR3 = false; + emit q->buttonR3Changed(false); + break; + case QGamepadManager::ButtonSelect: + buttonSelect = false; + emit q->buttonSelectChanged(false); + break; + case QGamepadManager::ButtonStart: + buttonStart = false; + emit q->buttonStartChanged(false); + break; + case QGamepadManager::ButtonUp: + buttonUp = false; + emit q->buttonUpChanged(false); + break; + case QGamepadManager::ButtonDown: + buttonDown = false; + emit q->buttonDownChanged(false); + break; + case QGamepadManager::ButtonLeft: + buttonLeft = false; + emit q->buttonLeftChanged(false); + break; + case QGamepadManager::ButtonRight: + buttonRight = false; + emit q->buttonRightChanged(false); + break; + case QGamepadManager::ButtonCenter: + buttonCenter = false; + emit q->buttonCenterChanged(false); + break; + case QGamepadManager::ButtonGuide: + buttonGuide = false; + emit q->buttonGuideChanged(false); + break; + default: + break; + } +} + /*! \class QGamepad \inmodule QtGamepad @@ -53,40 +360,17 @@ QT_BEGIN_NAMESPACE * \param parent */ QGamepad::QGamepad(int deviceId, QObject *parent) - : QObject(parent) - , m_deviceId(deviceId) - , m_connected(false) - , m_axisLeftX(0.0) - , m_axisLeftY(0.0) - , m_axisRightX(0.0) - , m_axisRightY(0.0) - , m_buttonA(false) - , m_buttonB(false) - , m_buttonX(false) - , m_buttonY(false) - , m_buttonL1(false) - , m_buttonR1(false) - , m_buttonL2(0.0) - , m_buttonR2(0.0) - , m_buttonSelect(false) - , m_buttonStart(false) - , m_buttonL3(false) - , m_buttonR3(false) - , m_buttonUp(false) - , m_buttonDown(false) - , m_buttonLeft(false) - , m_buttonRight(false) - , m_buttonCenter(false) - , m_buttonGuide(false) -{ - m_gamepadManager = QGamepadManager::instance(); - connect(m_gamepadManager, SIGNAL(gamepadConnected(int)), this, SLOT(handleGamepadConnected(int))); - connect(m_gamepadManager, SIGNAL(gamepadDisconnected(int)), this, SLOT(handleGamepadDisconnected(int))); - connect(m_gamepadManager, SIGNAL(gamepadAxisEvent(int,QGamepadManager::GamepadAxis,double)), this, SLOT(handleGamepadAxisEvent(int,QGamepadManager::GamepadAxis,double))); - connect(m_gamepadManager, SIGNAL(gamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double)), this, SLOT(handleGamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double))); - connect(m_gamepadManager, SIGNAL(gamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton)), this, SLOT(handleGamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton))); - - setConnected(m_gamepadManager->isGamepadConnected(m_deviceId)); + : QObject(*new QGamepadPrivate(deviceId), parent) +{ + Q_D(QGamepad); + d->gamepadManager = QGamepadManager::instance(); + connect(d->gamepadManager, SIGNAL(gamepadConnected(int)), this, SLOT(_q_handleGamepadConnected(int))); + connect(d->gamepadManager, SIGNAL(gamepadDisconnected(int)), this, SLOT(_q_handleGamepadDisconnected(int))); + connect(d->gamepadManager, SIGNAL(gamepadAxisEvent(int,QGamepadManager::GamepadAxis,double)), this, SLOT(_q_handleGamepadAxisEvent(int,QGamepadManager::GamepadAxis,double))); + connect(d->gamepadManager, SIGNAL(gamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double)), this, SLOT(_q_handleGamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double))); + connect(d->gamepadManager, SIGNAL(gamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton)), this, SLOT(_q_handleGamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton))); + + d->setConnected(d->gamepadManager->isGamepadConnected(deviceId)); } /*! @@ -106,7 +390,8 @@ QGamepad::~QGamepad() */ int QGamepad::deviceId() const { - return m_deviceId; + Q_D(const QGamepad); + return d->deviceId; } /*! @@ -116,7 +401,8 @@ int QGamepad::deviceId() const */ bool QGamepad::isConnected() const { - return m_connected; + Q_D(const QGamepad); + return d->connected; } /*! @@ -126,7 +412,8 @@ bool QGamepad::isConnected() const */ QString QGamepad::name() const { - return m_name; + Q_D(const QGamepad); + return d->name; } /*! @@ -137,7 +424,8 @@ QString QGamepad::name() const */ double QGamepad::axisLeftX() const { - return m_axisLeftX; + Q_D(const QGamepad); + return d->axisLeftX; } /*! @@ -148,7 +436,8 @@ double QGamepad::axisLeftX() const */ double QGamepad::axisLeftY() const { - return m_axisLeftY; + Q_D(const QGamepad); + return d->axisLeftY; } /*! @@ -159,7 +448,8 @@ double QGamepad::axisLeftY() const */ double QGamepad::axisRightX() const { - return m_axisRightX; + Q_D(const QGamepad); + return d->axisRightX; } /*! @@ -170,7 +460,8 @@ double QGamepad::axisRightX() const */ double QGamepad::axisRightY() const { - return m_axisRightY; + Q_D(const QGamepad); + return d->axisRightY; } /*! @@ -181,7 +472,8 @@ double QGamepad::axisRightY() const */ bool QGamepad::buttonA() const { - return m_buttonA; + Q_D(const QGamepad); + return d->buttonA; } /*! @@ -192,7 +484,8 @@ bool QGamepad::buttonA() const */ bool QGamepad::buttonB() const { - return m_buttonB; + Q_D(const QGamepad); + return d->buttonB; } /*! @@ -203,7 +496,8 @@ bool QGamepad::buttonB() const */ bool QGamepad::buttonX() const { - return m_buttonX; + Q_D(const QGamepad); + return d->buttonX; } /*! @@ -214,7 +508,8 @@ bool QGamepad::buttonX() const */ bool QGamepad::buttonY() const { - return m_buttonY; + Q_D(const QGamepad); + return d->buttonY; } /*! @@ -225,7 +520,8 @@ bool QGamepad::buttonY() const */ bool QGamepad::buttonL1() const { - return m_buttonL1; + Q_D(const QGamepad); + return d->buttonL1; } /*! @@ -236,7 +532,8 @@ bool QGamepad::buttonL1() const */ bool QGamepad::buttonR1() const { - return m_buttonR1; + Q_D(const QGamepad); + return d->buttonR1; } /*! @@ -248,7 +545,8 @@ bool QGamepad::buttonR1() const */ double QGamepad::buttonL2() const { - return m_buttonL2; + Q_D(const QGamepad); + return d->buttonL2; } /*! @@ -260,7 +558,8 @@ double QGamepad::buttonL2() const */ double QGamepad::buttonR2() const { - return m_buttonR2; + Q_D(const QGamepad); + return d->buttonR2; } /*! @@ -271,7 +570,8 @@ double QGamepad::buttonR2() const */ bool QGamepad::buttonSelect() const { - return m_buttonSelect; + Q_D(const QGamepad); + return d->buttonSelect; } /*! @@ -282,7 +582,8 @@ bool QGamepad::buttonSelect() const */ bool QGamepad::buttonStart() const { - return m_buttonStart; + Q_D(const QGamepad); + return d->buttonStart; } /*! @@ -293,7 +594,8 @@ bool QGamepad::buttonStart() const */ bool QGamepad::buttonL3() const { - return m_buttonL3; + Q_D(const QGamepad); + return d->buttonL3; } /*! @@ -304,7 +606,8 @@ bool QGamepad::buttonL3() const */ bool QGamepad::buttonR3() const { - return m_buttonR3; + Q_D(const QGamepad); + return d->buttonR3; } /*! @@ -315,7 +618,8 @@ bool QGamepad::buttonR3() const */ bool QGamepad::buttonUp() const { - return m_buttonUp; + Q_D(const QGamepad); + return d->buttonUp; } /*! @@ -326,7 +630,8 @@ bool QGamepad::buttonUp() const */ bool QGamepad::buttonDown() const { - return m_buttonDown; + Q_D(const QGamepad); + return d->buttonDown; } /*! @@ -337,7 +642,8 @@ bool QGamepad::buttonDown() const */ bool QGamepad::buttonLeft() const { - return m_buttonLeft; + Q_D(const QGamepad); + return d->buttonLeft; } /*! @@ -348,12 +654,14 @@ bool QGamepad::buttonLeft() const */ bool QGamepad::buttonRight() const { - return m_buttonRight; + Q_D(const QGamepad); + return d->buttonRight; } bool QGamepad::buttonCenter() const { - return m_buttonCenter; + Q_D(const QGamepad); + return d->buttonCenter; } /*! @@ -366,247 +674,20 @@ bool QGamepad::buttonCenter() const */ bool QGamepad::buttonGuide() const { - return m_buttonGuide; + Q_D(const QGamepad); + return d->buttonGuide; } void QGamepad::setDeviceId(int number) { - if (m_deviceId != number) { - m_deviceId = number; + Q_D(QGamepad); + if (d->deviceId != number) { + d->deviceId = number; emit deviceIdChanged(number); - setConnected(m_gamepadManager->isGamepadConnected(m_deviceId)); - } -} - -void QGamepad::setConnected(bool isConnected) -{ - if (m_connected != isConnected) { - m_connected = isConnected; - emit connectedChanged(m_connected); - } -} - -/*! - * \internal - */\ -void QGamepad::handleGamepadConnected(int deviceId) -{ - if (deviceId == m_deviceId) { - setConnected(true); - } -} - -/*! - * \internal - */\ -void QGamepad::handleGamepadDisconnected(int deviceId) -{ - if (deviceId == m_deviceId) { - setConnected(false); - } -} - -/*! - * \internal - */\ -void QGamepad::handleGamepadAxisEvent(int deviceId, QGamepadManager::GamepadAxis axis, double value) -{ - if (deviceId != m_deviceId) - return; - - switch (axis) { - case QGamepadManager::AxisLeftX: - m_axisLeftX = value; - emit axisLeftXChanged(value); - break; - case QGamepadManager::AxisLeftY: - m_axisLeftY = value; - emit axisLeftYChanged(value); - break; - case QGamepadManager::AxisRightX: - m_axisRightX = value; - emit axisRightXChanged(value); - break; - case QGamepadManager::AxisRightY: - m_axisRightY = value; - emit axisRightYChanged(value); - break; - default: - break; - } -} - -/*! - * \internal - */\ -void QGamepad::handleGamepadButtonPressEvent(int deviceId, QGamepadManager::GamepadButton button, double value) -{ - if (deviceId != m_deviceId) - return; - - switch (button) { - case QGamepadManager::ButtonA: - m_buttonA = true; - emit buttonAChanged(true); - break; - case QGamepadManager::ButtonB: - m_buttonB = true; - emit buttonBChanged(true); - break; - case QGamepadManager::ButtonX: - m_buttonX = true; - emit buttonXChanged(true); - break; - case QGamepadManager::ButtonY: - m_buttonY = true; - emit buttonYChanged(true); - break; - case QGamepadManager::ButtonL1: - m_buttonL1 = true; - emit buttonL1Changed(true); - break; - case QGamepadManager::ButtonR1: - m_buttonR1 = true; - emit buttonR1Changed(true); - break; - case QGamepadManager::ButtonL2: - m_buttonL2 = value; - emit buttonL2Changed(value); - break; - case QGamepadManager::ButtonR2: - m_buttonR2 = value; - emit buttonR2Changed(value); - break; - case QGamepadManager::ButtonL3: - m_buttonL3 = true; - emit buttonL3Changed(true); - break; - case QGamepadManager::ButtonR3: - m_buttonR3 = true; - emit buttonR3Changed(true); - break; - case QGamepadManager::ButtonSelect: - m_buttonSelect = true; - emit buttonSelectChanged(true); - break; - case QGamepadManager::ButtonStart: - m_buttonStart = true; - emit buttonStartChanged(true); - break; - case QGamepadManager::ButtonUp: - m_buttonUp = true; - emit buttonUpChanged(true); - break; - case QGamepadManager::ButtonDown: - m_buttonDown = true; - emit buttonDownChanged(true); - break; - case QGamepadManager::ButtonLeft: - m_buttonLeft = true; - emit buttonLeftChanged(true); - break; - case QGamepadManager::ButtonRight: - m_buttonRight = true; - emit buttonRightChanged(true); - break; - case QGamepadManager::ButtonCenter: - m_buttonCenter = true; - emit buttonCenterChanged(true); - break; - case QGamepadManager::ButtonGuide: - m_buttonGuide = true; - emit buttonGuideChanged(true); - break; - default: - break; - } - -} - -/*! - * \internal - */\ -void QGamepad::handleGamepadButtonReleaseEvent(int deviceId, QGamepadManager::GamepadButton button) -{ - if (deviceId != m_deviceId) - return; - - switch (button) { - case QGamepadManager::ButtonA: - m_buttonA = false; - emit buttonAChanged(false); - break; - case QGamepadManager::ButtonB: - m_buttonB = false; - emit buttonBChanged(false); - break; - case QGamepadManager::ButtonX: - m_buttonX = false; - emit buttonXChanged(false); - break; - case QGamepadManager::ButtonY: - m_buttonY = false; - emit buttonYChanged(false); - break; - case QGamepadManager::ButtonL1: - m_buttonL1 = false; - emit buttonL1Changed(false); - break; - case QGamepadManager::ButtonR1: - m_buttonR1 = false; - emit buttonR1Changed(false); - break; - case QGamepadManager::ButtonL2: - m_buttonL2 = 0.0; - emit buttonL2Changed(0.0); - break; - case QGamepadManager::ButtonR2: - m_buttonR2 = 0.0; - emit buttonR2Changed(0.0); - break; - case QGamepadManager::ButtonL3: - m_buttonL3 = false; - emit buttonL3Changed(false); - break; - case QGamepadManager::ButtonR3: - m_buttonR3 = false; - emit buttonR3Changed(false); - break; - case QGamepadManager::ButtonSelect: - m_buttonSelect = false; - emit buttonSelectChanged(false); - break; - case QGamepadManager::ButtonStart: - m_buttonStart = false; - emit buttonStartChanged(false); - break; - case QGamepadManager::ButtonUp: - m_buttonUp = false; - emit buttonUpChanged(false); - break; - case QGamepadManager::ButtonDown: - m_buttonDown = false; - emit buttonDownChanged(false); - break; - case QGamepadManager::ButtonLeft: - m_buttonLeft = false; - emit buttonLeftChanged(false); - break; - case QGamepadManager::ButtonRight: - m_buttonRight = false; - emit buttonRightChanged(false); - break; - case QGamepadManager::ButtonCenter: - m_buttonCenter = false; - emit buttonCenterChanged(false); - break; - case QGamepadManager::ButtonGuide: - m_buttonGuide = false; - emit buttonGuideChanged(false); - break; - default: - break; + d->setConnected(d->gamepadManager->isGamepadConnected(d->deviceId)); } } QT_END_NAMESPACE + +#include "moc_qgamepad.cpp" diff --git a/src/gamepad/qgamepad.h b/src/gamepad/qgamepad.h index 2c99e85..fcc08f3 100644 --- a/src/gamepad/qgamepad.h +++ b/src/gamepad/qgamepad.h @@ -43,6 +43,8 @@ QT_BEGIN_NAMESPACE +class QGamepadPrivate; + class Q_GAMEPAD_EXPORT QGamepad : public QObject { Q_OBJECT @@ -136,44 +138,14 @@ public Q_SLOTS: void setDeviceId(int number); -private Q_SLOTS: - void setConnected(bool isConnected); - - void handleGamepadConnected(int deviceId); - void handleGamepadDisconnected(int deviceId); - void handleGamepadAxisEvent(int deviceId, QGamepadManager::GamepadAxis axis, double value); - void handleGamepadButtonPressEvent(int deviceId, QGamepadManager::GamepadButton button, double value); - void handleGamepadButtonReleaseEvent(int deviceId, QGamepadManager::GamepadButton button); - private: - - QGamepadManager *m_gamepadManager; - - int m_deviceId; - bool m_connected; - QString m_name; - double m_axisLeftX; - double m_axisLeftY; - double m_axisRightX; - double m_axisRightY; - bool m_buttonA; - bool m_buttonB; - bool m_buttonX; - bool m_buttonY; - bool m_buttonL1; - bool m_buttonR1; - double m_buttonL2; - double m_buttonR2; - bool m_buttonSelect; - bool m_buttonStart; - bool m_buttonL3; - bool m_buttonR3; - bool m_buttonUp; - bool m_buttonDown; - bool m_buttonLeft; - bool m_buttonRight; - bool m_buttonCenter; - bool m_buttonGuide; + Q_DECLARE_PRIVATE(QGamepad) + Q_DISABLE_COPY(QGamepad) + Q_PRIVATE_SLOT(d_func(), void _q_handleGamepadConnected(int)) + Q_PRIVATE_SLOT(d_func(), void _q_handleGamepadDisconnected(int)) + Q_PRIVATE_SLOT(d_func(), void _q_handleGamepadAxisEvent(int, QGamepadManager::GamepadAxis, double)) + Q_PRIVATE_SLOT(d_func(), void _q_handleGamepadButtonPressEvent(int, QGamepadManager::GamepadButton, double)) + Q_PRIVATE_SLOT(d_func(), void _q_handleGamepadButtonReleaseEvent(int, QGamepadManager::GamepadButton)) }; QT_END_NAMESPACE diff --git a/src/gamepad/qgamepadkeynavigation.cpp b/src/gamepad/qgamepadkeynavigation.cpp index d88363a..a317ed0 100644 --- a/src/gamepad/qgamepadkeynavigation.cpp +++ b/src/gamepad/qgamepadkeynavigation.cpp @@ -40,337 +40,402 @@ #include #include +#include + QT_BEGIN_NAMESPACE +class QGamepadKeyNavigationPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QGamepadKeyNavigation) +public: + QGamepadKeyNavigationPrivate() + : active(true) + , gamepad(nullptr) + , buttonL2Pressed(false) + , buttonR2Pressed(false) + { + } + + void sendGeneratedKeyEvent(QKeyEvent *event); + + bool active; + QGamepad *gamepad; + QGamepadManager *gamepadManger; + bool buttonL2Pressed; + bool buttonR2Pressed; + QMap keyMapping; + + void _q_processGamepadButtonPressEvent(int index, QGamepadManager::GamepadButton button, double value); + void _q_processGamepadButtonReleaseEvent(int index, QGamepadManager::GamepadButton button); +}; + +void QGamepadKeyNavigationPrivate::sendGeneratedKeyEvent(QKeyEvent *event) +{ + if (!active) { + delete event; + return; + } + const QGuiApplication *app = qApp; + QWindow *focusWindow = app ? app->focusWindow() : 0; + if (focusWindow) + QGuiApplication::sendEvent(focusWindow, event); +} + +void QGamepadKeyNavigationPrivate::_q_processGamepadButtonPressEvent(int index, QGamepadManager::GamepadButton button, double value) +{ + Q_UNUSED(value) + //If a gamepad has been set then, only use the events of that gamepad + if (gamepad && gamepad->deviceId() != index) + return; + + //Trigger buttons are a special case as they get multiple press events as the value changes + if (button == QGamepadManager::ButtonL2 && buttonL2Pressed) + return; + else + buttonL2Pressed = true; + if (button == QGamepadManager::ButtonR2 && buttonR2Pressed) + return; + else + buttonR2Pressed = true; + + QKeyEvent *event = new QKeyEvent(QEvent::KeyPress, keyMapping[button], Qt::NoModifier); + sendGeneratedKeyEvent(event); +} + +void QGamepadKeyNavigationPrivate::_q_processGamepadButtonReleaseEvent(int index, QGamepadManager::GamepadButton button) +{ + //If a gamepad has been set then, only use the events of that gamepad + if (gamepad && gamepad->deviceId() != index) + return; + + //Free the trigger buttons if necessary + if (button == QGamepadManager::ButtonL2) + buttonL2Pressed = false; + if (button == QGamepadManager::ButtonR2) + buttonR2Pressed = false; + + QKeyEvent *event = new QKeyEvent(QEvent::KeyRelease, keyMapping[button], Qt::NoModifier); + sendGeneratedKeyEvent(event); +} + QGamepadKeyNavigation::QGamepadKeyNavigation(QObject *parent) - : QObject(parent) - , m_active(true) - , m_gamepad(Q_NULLPTR) - , m_buttonL2Pressed(false) - , m_buttonR2Pressed(false) + : QObject(*new QGamepadKeyNavigationPrivate(), parent) { - m_gamepadManger = QGamepadManager::instance(); + Q_D(QGamepadKeyNavigation); + d->gamepadManger = QGamepadManager::instance(); //Default keymap - m_keyMapping.insert(QGamepadManager::ButtonUp, Qt::Key_Up); - m_keyMapping.insert(QGamepadManager::ButtonDown, Qt::Key_Down); - m_keyMapping.insert(QGamepadManager::ButtonLeft, Qt::Key_Left); - m_keyMapping.insert(QGamepadManager::ButtonRight, Qt::Key_Right); - m_keyMapping.insert(QGamepadManager::ButtonA, Qt::Key_Return); - m_keyMapping.insert(QGamepadManager::ButtonB, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonX, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonY, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonSelect, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonStart, Qt::Key_Return); - m_keyMapping.insert(QGamepadManager::ButtonGuide, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonL1, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonR1, Qt::Key_Forward); - m_keyMapping.insert(QGamepadManager::ButtonL2, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonR2, Qt::Key_Forward); - m_keyMapping.insert(QGamepadManager::ButtonL3, Qt::Key_Back); - m_keyMapping.insert(QGamepadManager::ButtonR3, Qt::Key_Forward); - - connect(m_gamepadManger, SIGNAL(gamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double)), - this, SLOT(processGamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double))); - connect(m_gamepadManger, SIGNAL(gamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton)), - this, SLOT(procressGamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton))); + d->keyMapping.insert(QGamepadManager::ButtonUp, Qt::Key_Up); + d->keyMapping.insert(QGamepadManager::ButtonDown, Qt::Key_Down); + d->keyMapping.insert(QGamepadManager::ButtonLeft, Qt::Key_Left); + d->keyMapping.insert(QGamepadManager::ButtonRight, Qt::Key_Right); + d->keyMapping.insert(QGamepadManager::ButtonA, Qt::Key_Return); + d->keyMapping.insert(QGamepadManager::ButtonB, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonX, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonY, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonSelect, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonStart, Qt::Key_Return); + d->keyMapping.insert(QGamepadManager::ButtonGuide, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonL1, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonR1, Qt::Key_Forward); + d->keyMapping.insert(QGamepadManager::ButtonL2, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonR2, Qt::Key_Forward); + d->keyMapping.insert(QGamepadManager::ButtonL3, Qt::Key_Back); + d->keyMapping.insert(QGamepadManager::ButtonR3, Qt::Key_Forward); + + connect(d->gamepadManger, SIGNAL(gamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double)), + this, SLOT(_q_processGamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double))); + connect(d->gamepadManger, SIGNAL(gamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton)), + this, SLOT(_q_processGamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton))); } bool QGamepadKeyNavigation::active() const { - return m_active; + Q_D(const QGamepadKeyNavigation); + return d->active; } QGamepad *QGamepadKeyNavigation::gamepad() const { - return m_gamepad; + Q_D(const QGamepadKeyNavigation); + return d->gamepad; } Qt::Key QGamepadKeyNavigation::upKey() const { - return m_keyMapping[QGamepadManager::ButtonUp]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonUp]; } Qt::Key QGamepadKeyNavigation::downKey() const { - return m_keyMapping[QGamepadManager::ButtonDown]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonDown]; } Qt::Key QGamepadKeyNavigation::leftKey() const { - return m_keyMapping[QGamepadManager::ButtonLeft]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonLeft]; } Qt::Key QGamepadKeyNavigation::rightKey() const { - return m_keyMapping[QGamepadManager::ButtonRight]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonRight]; } Qt::Key QGamepadKeyNavigation::buttonAKey() const { - return m_keyMapping[QGamepadManager::ButtonA]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonA]; } Qt::Key QGamepadKeyNavigation::buttonBKey() const { - return m_keyMapping[QGamepadManager::ButtonB]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonB]; } Qt::Key QGamepadKeyNavigation::buttonXKey() const { - return m_keyMapping[QGamepadManager::ButtonX]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonX]; } Qt::Key QGamepadKeyNavigation::buttonYKey() const { - return m_keyMapping[QGamepadManager::ButtonY]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonY]; } Qt::Key QGamepadKeyNavigation::buttonSelectKey() const { - return m_keyMapping[QGamepadManager::ButtonSelect]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonSelect]; } Qt::Key QGamepadKeyNavigation::buttonStartKey() const { - return m_keyMapping[QGamepadManager::ButtonStart]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonStart]; } Qt::Key QGamepadKeyNavigation::buttonGuideKey() const { - return m_keyMapping[QGamepadManager::ButtonGuide]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonGuide]; } Qt::Key QGamepadKeyNavigation::buttonL1Key() const { - return m_keyMapping[QGamepadManager::ButtonL1]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonL1]; } Qt::Key QGamepadKeyNavigation::buttonR1Key() const { - return m_keyMapping[QGamepadManager::ButtonL2]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonL2]; } Qt::Key QGamepadKeyNavigation::buttonL2Key() const { - return m_keyMapping[QGamepadManager::ButtonL2]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonL2]; } Qt::Key QGamepadKeyNavigation::buttonR2Key() const { - return m_keyMapping[QGamepadManager::ButtonL2]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonL2]; } Qt::Key QGamepadKeyNavigation::buttonL3Key() const { - return m_keyMapping[QGamepadManager::ButtonL3]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonL3]; } Qt::Key QGamepadKeyNavigation::buttonR3Key() const { - return m_keyMapping[QGamepadManager::ButtonL3]; + Q_D(const QGamepadKeyNavigation); + return d->keyMapping[QGamepadManager::ButtonL3]; } void QGamepadKeyNavigation::setActive(bool isActive) { - if (m_active != isActive) { - m_active = isActive; + Q_D(QGamepadKeyNavigation); + if (d->active != isActive) { + d->active = isActive; emit activeChanged(isActive); } } void QGamepadKeyNavigation::setGamepad(QGamepad *gamepad) { - if (m_gamepad != gamepad) { - m_gamepad = gamepad; + Q_D(QGamepadKeyNavigation); + if (d->gamepad != gamepad) { + d->gamepad = gamepad; emit gamepadChanged(gamepad); } } void QGamepadKeyNavigation::setUpKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonUp] != key) { - m_keyMapping[QGamepadManager::ButtonUp] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonUp] != key) { + d->keyMapping[QGamepadManager::ButtonUp] = key; emit upKeyChanged(key); } } void QGamepadKeyNavigation::setDownKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonDown] != key) { - m_keyMapping[QGamepadManager::ButtonDown] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonDown] != key) { + d->keyMapping[QGamepadManager::ButtonDown] = key; emit downKeyChanged(key); } } void QGamepadKeyNavigation::setLeftKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonLeft] != key) { - m_keyMapping[QGamepadManager::ButtonLeft] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonLeft] != key) { + d->keyMapping[QGamepadManager::ButtonLeft] = key; emit leftKeyChanged(key); } } void QGamepadKeyNavigation::setRightKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonRight] != key) { - m_keyMapping[QGamepadManager::ButtonRight] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonRight] != key) { + d->keyMapping[QGamepadManager::ButtonRight] = key; emit rightKeyChanged(key); } } void QGamepadKeyNavigation::setButtonAKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonA] != key) { - m_keyMapping[QGamepadManager::ButtonA] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonA] != key) { + d->keyMapping[QGamepadManager::ButtonA] = key; emit buttonAKeyChanged(key); } } void QGamepadKeyNavigation::setButtonBKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonB] != key) { - m_keyMapping[QGamepadManager::ButtonB] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonB] != key) { + d->keyMapping[QGamepadManager::ButtonB] = key; emit buttonBKeyChanged(key); } } void QGamepadKeyNavigation::setButtonXKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonX] != key) { - m_keyMapping[QGamepadManager::ButtonX] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonX] != key) { + d->keyMapping[QGamepadManager::ButtonX] = key; emit buttonXKeyChanged(key); } } void QGamepadKeyNavigation::setButtonYKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonY] != key) { - m_keyMapping[QGamepadManager::ButtonY] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonY] != key) { + d->keyMapping[QGamepadManager::ButtonY] = key; emit buttonYKeyChanged(key); } } void QGamepadKeyNavigation::setButtonSelectKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonSelect] != key) { - m_keyMapping[QGamepadManager::ButtonSelect] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonSelect] != key) { + d->keyMapping[QGamepadManager::ButtonSelect] = key; emit buttonSelectKeyChanged(key); } } void QGamepadKeyNavigation::setButtonStartKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonStart] != key) { - m_keyMapping[QGamepadManager::ButtonStart] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonStart] != key) { + d->keyMapping[QGamepadManager::ButtonStart] = key; emit buttonStartKeyChanged(key); } } void QGamepadKeyNavigation::setButtonGuideKey(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonGuide] != key) { - m_keyMapping[QGamepadManager::ButtonGuide] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonGuide] != key) { + d->keyMapping[QGamepadManager::ButtonGuide] = key; emit buttonGuideKeyChanged(key); } } void QGamepadKeyNavigation::setButtonL1Key(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonL1] != key) { - m_keyMapping[QGamepadManager::ButtonL1] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonL1] != key) { + d->keyMapping[QGamepadManager::ButtonL1] = key; emit buttonL1KeyChanged(key); } } void QGamepadKeyNavigation::setButtonR1Key(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonR1] != key) { - m_keyMapping[QGamepadManager::ButtonR1] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonR1] != key) { + d->keyMapping[QGamepadManager::ButtonR1] = key; emit buttonR1KeyChanged(key); } } void QGamepadKeyNavigation::setButtonL2Key(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonL2] != key) { - m_keyMapping[QGamepadManager::ButtonL2] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonL2] != key) { + d->keyMapping[QGamepadManager::ButtonL2] = key; emit buttonL1KeyChanged(key); } } void QGamepadKeyNavigation::setButtonR2Key(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonR2] != key) { - m_keyMapping[QGamepadManager::ButtonR2] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonR2] != key) { + d->keyMapping[QGamepadManager::ButtonR2] = key; emit buttonR1KeyChanged(key); } } void QGamepadKeyNavigation::setButtonL3Key(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonL3] != key) { - m_keyMapping[QGamepadManager::ButtonL3] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonL3] != key) { + d->keyMapping[QGamepadManager::ButtonL3] = key; emit buttonL1KeyChanged(key); } } void QGamepadKeyNavigation::setButtonR3Key(Qt::Key key) { - if (m_keyMapping[QGamepadManager::ButtonR3] != key) { - m_keyMapping[QGamepadManager::ButtonR3] = key; + Q_D(QGamepadKeyNavigation); + if (d->keyMapping[QGamepadManager::ButtonR3] != key) { + d->keyMapping[QGamepadManager::ButtonR3] = key; emit buttonR1KeyChanged(key); } } -void QGamepadKeyNavigation::processGamepadButtonPressEvent(int index, QGamepadManager::GamepadButton button, double value) -{ - Q_UNUSED(value) - - //If a gamepad has been set then, only use the events of that gamepad - if (m_gamepad && m_gamepad->deviceId() != index) - return; - - //Trigger buttons are a special case as they get multiple press events as the value changes - if (button == QGamepadManager::ButtonL2 && m_buttonL2Pressed) - return; - else - m_buttonL2Pressed = true; - if (button == QGamepadManager::ButtonR2 && m_buttonR2Pressed) - return; - else - m_buttonR2Pressed = true; - - QKeyEvent *event = new QKeyEvent(QEvent::KeyPress, m_keyMapping[button], Qt::NoModifier); - sendGeneratedKeyEvent(event); -} - -void QGamepadKeyNavigation::procressGamepadButtonReleaseEvent(int index, QGamepadManager::GamepadButton button) -{ - //If a gamepad has been set then, only use the events of that gamepad - if (m_gamepad && m_gamepad->deviceId() != index) - return; - - //Free the trigger buttons if necessary - if (button == QGamepadManager::ButtonL2) - m_buttonL2Pressed = false; - if (button == QGamepadManager::ButtonR2) - m_buttonR2Pressed = false; - QKeyEvent *event = new QKeyEvent(QEvent::KeyRelease, m_keyMapping[button], Qt::NoModifier); - sendGeneratedKeyEvent(event); -} - -void QGamepadKeyNavigation::sendGeneratedKeyEvent(QKeyEvent *event) -{ - if (!m_active) { - delete event; - return; - } - const QGuiApplication *app = qApp; - QWindow *focusWindow = app ? app->focusWindow() : 0; - if (focusWindow) - QGuiApplication::sendEvent(focusWindow, event); -} QT_END_NAMESPACE + +#include "moc_qgamepadkeynavigation.cpp" diff --git a/src/gamepad/qgamepadkeynavigation.h b/src/gamepad/qgamepadkeynavigation.h index 9bd599c..fca7714 100644 --- a/src/gamepad/qgamepadkeynavigation.h +++ b/src/gamepad/qgamepadkeynavigation.h @@ -47,6 +47,7 @@ QT_BEGIN_NAMESPACE class QKeyEvent; class QGamepad; +class QGamepadKeyNavigationPrivate; class Q_GAMEPAD_EXPORT QGamepadKeyNavigation : public QObject { Q_OBJECT @@ -137,19 +138,11 @@ public Q_SLOTS: void setButtonL3Key(Qt::Key key); void setButtonR3Key(Qt::Key key); -private Q_SLOTS: - void processGamepadButtonPressEvent(int index, QGamepadManager::GamepadButton button, double value); - void procressGamepadButtonReleaseEvent(int index, QGamepadManager::GamepadButton button); - private: - void sendGeneratedKeyEvent(QKeyEvent *event); - - bool m_active; - QGamepad *m_gamepad; - QGamepadManager *m_gamepadManger; - bool m_buttonL2Pressed; - bool m_buttonR2Pressed; - QMap m_keyMapping; + Q_DECLARE_PRIVATE(QGamepadKeyNavigation) + Q_DISABLE_COPY(QGamepadKeyNavigation) + Q_PRIVATE_SLOT(d_func(), void _q_processGamepadButtonPressEvent(int, QGamepadManager::GamepadButton, double)) + Q_PRIVATE_SLOT(d_func(), void _q_processGamepadButtonReleaseEvent(int, QGamepadManager::GamepadButton)) }; QT_END_NAMESPACE diff --git a/src/gamepad/qgamepadmanager.cpp b/src/gamepad/qgamepadmanager.cpp index 2c737f6..51912ad 100644 --- a/src/gamepad/qgamepadmanager.cpp +++ b/src/gamepad/qgamepadmanager.cpp @@ -41,38 +41,70 @@ #include +#include + QT_BEGIN_NAMESPACE Q_LOGGING_CATEGORY(gp, "qt.gamepad") -QGamepadManager::QGamepadManager() : - QObject(0) +class QGamepadManagerPrivate : public QObjectPrivate { - loadBackend(); + Q_DECLARE_PUBLIC(QGamepadManager) +public: + QGamepadManagerPrivate() + : gamepadBackend(nullptr) + { + loadBackend(); + } - qRegisterMetaType("QGamepadManager::GamepadButton"); - qRegisterMetaType("QGamepadManager::GamepadAxis"); + void loadBackend(); - connect(m_gamepadBackend, SIGNAL(gamepadAdded(int)), this, SLOT(forwardGamepadConnected(int))); - connect(m_gamepadBackend, SIGNAL(gamepadRemoved(int)), this, SLOT(forwardGamepadDisconnected(int))); - connect(m_gamepadBackend, SIGNAL(gamepadAxisMoved(int,QGamepadManager::GamepadAxis,double)), this, SLOT(forwardGamepadAxisEvent(int,QGamepadManager::GamepadAxis,double))); - connect(m_gamepadBackend, SIGNAL(gamepadButtonPressed(int,QGamepadManager::GamepadButton,double)), this, SLOT(forwardGamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double))); - connect(m_gamepadBackend, SIGNAL(gamepadButtonReleased(int,QGamepadManager::GamepadButton)), this, SLOT(forwardGamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton))); - connect(m_gamepadBackend, &QGamepadBackend::buttonConfigured, this, &QGamepadManager::buttonConfigured); - connect(m_gamepadBackend, &QGamepadBackend::axisConfigured, this, &QGamepadManager::axisConfigured); - connect(m_gamepadBackend, &QGamepadBackend::configurationCanceled, this, &QGamepadManager::configurationCanceled); + QGamepadBackend *gamepadBackend; + QSet connectedGamepads; - if (!m_gamepadBackend->start()) - qCWarning(gp) << "Failed to start gamepad backend"; + //private slots + void _q_forwardGamepadConnected(int deviceId); + 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); + emit q->gamepadConnected(deviceId); + emit q->connectedGamepadsChanged(); } -QGamepadManager::~QGamepadManager() +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) { - m_gamepadBackend->stop(); - m_gamepadBackend->deleteLater(); + Q_Q(QGamepadManager); + emit q->gamepadAxisEvent(deviceId, axis, value); } -void QGamepadManager::loadBackend() +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; @@ -83,95 +115,100 @@ void QGamepadManager::loadBackend() targetKey = requestedKey; if (!targetKey.isEmpty()) { qCDebug(gp) << "Loading backend" << targetKey; - m_gamepadBackend = QGamepadBackendFactory::create(targetKey, QStringList()); + gamepadBackend = QGamepadBackendFactory::create(targetKey, QStringList()); } } - if (!m_gamepadBackend) { + if (!gamepadBackend) { //Use dummy backend - m_gamepadBackend = new QGamepadBackend(); + gamepadBackend = new QGamepadBackend(); qCDebug(gp) << "Using dummy backend"; } } -QGamepadManager *QGamepadManager::instance() +QGamepadManager::QGamepadManager() : + QObject(*new QGamepadManagerPrivate(), 0) { - static QGamepadManager instance; - return &instance; -} + Q_D(QGamepadManager); -bool QGamepadManager::isGamepadConnected(int deviceId) -{ - return m_connectedGamepads.contains(deviceId); -} + qRegisterMetaType("QGamepadManager::GamepadButton"); + qRegisterMetaType("QGamepadManager::GamepadAxis"); -const QList QGamepadManager::connectedGamepads() const -{ - return m_connectedGamepads.toList(); -} + connect(d->gamepadBackend, SIGNAL(gamepadAdded(int)), this, SLOT(_q_forwardGamepadConnected(int))); + 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))); -bool QGamepadManager::isConfigurationNeeded(int deviceId) -{ - return m_gamepadBackend->isConfigurationNeeded(deviceId); + 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"; } -bool QGamepadManager::configureButton(int deviceId, QGamepadManager::GamepadButton button) +QGamepadManager::~QGamepadManager() { - return m_gamepadBackend->configureButton(deviceId, button); + Q_D(QGamepadManager); + d->gamepadBackend->stop(); + d->gamepadBackend->deleteLater(); } -bool QGamepadManager::configureAxis(int deviceId, QGamepadManager::GamepadAxis axis) +QGamepadManager *QGamepadManager::instance() { - return m_gamepadBackend->configureAxis(deviceId, axis); + static QGamepadManager instance; + return &instance; } -bool QGamepadManager::setCancelConfigureButton(int deviceId, QGamepadManager::GamepadButton button) +bool QGamepadManager::isGamepadConnected(int deviceId) const { - return m_gamepadBackend->setCancelConfigureButton(deviceId, button); + Q_D(const QGamepadManager); + return d->connectedGamepads.contains(deviceId); } -void QGamepadManager::resetConfiguration(int deviceId) +const QList QGamepadManager::connectedGamepads() const { - m_gamepadBackend->resetConfiguration(deviceId); + Q_D(const QGamepadManager); + return d->connectedGamepads.toList(); } -void QGamepadManager::setSettingsFile(const QString &file) +bool QGamepadManager::isConfigurationNeeded(int deviceId) const { - m_gamepadBackend->setSettingsFile(file); + Q_D(const QGamepadManager); + return d->gamepadBackend->isConfigurationNeeded(deviceId); } -void QGamepadManager::forwardGamepadConnected(int deviceId) +bool QGamepadManager::configureButton(int deviceId, QGamepadManager::GamepadButton button) { - //qDebug() << "gamepad connected: " << index; - m_connectedGamepads.insert(deviceId); - emit gamepadConnected(deviceId); - emit connectedGamepadsChanged(); + Q_D(QGamepadManager); + return d->gamepadBackend->configureButton(deviceId, button); } -void QGamepadManager::forwardGamepadDisconnected(int deviceId) +bool QGamepadManager::configureAxis(int deviceId, QGamepadManager::GamepadAxis axis) { - //qDebug() << "gamepad disconnected: " << index; - m_connectedGamepads.remove(deviceId); - emit gamepadDisconnected(deviceId); - emit connectedGamepadsChanged(); + Q_D(QGamepadManager); + return d->gamepadBackend->configureAxis(deviceId, axis); } -void QGamepadManager::forwardGamepadAxisEvent(int deviceId, QGamepadManager::GamepadAxis axis, double value) +bool QGamepadManager::setCancelConfigureButton(int deviceId, QGamepadManager::GamepadButton button) { - //qDebug() << "gamepad axis event: " << index << axis << value; - emit gamepadAxisEvent(deviceId, axis, value); + Q_D(QGamepadManager); + return d->gamepadBackend->setCancelConfigureButton(deviceId, button); } -void QGamepadManager::forwardGamepadButtonPressEvent(int deviceId, QGamepadManager::GamepadButton button, double value) +void QGamepadManager::resetConfiguration(int deviceId) { - //qDebug() << "gamepad button press event: " << index << button << value; - emit gamepadButtonPressEvent(deviceId, button, value); + Q_D(QGamepadManager); + d->gamepadBackend->resetConfiguration(deviceId); } -void QGamepadManager::forwardGamepadButtonReleaseEvent(int deviceId, QGamepadManager::GamepadButton button) +void QGamepadManager::setSettingsFile(const QString &file) { - //qDebug() << "gamepad button release event: " << index << button; - emit gamepadButtonReleaseEvent(deviceId, button); + Q_D(QGamepadManager); + d->gamepadBackend->setSettingsFile(file); } QT_END_NAMESPACE + +#include "moc_qgamepadmanager.cpp" diff --git a/src/gamepad/qgamepadmanager.h b/src/gamepad/qgamepadmanager.h index 191b998..20fda67 100644 --- a/src/gamepad/qgamepadmanager.h +++ b/src/gamepad/qgamepadmanager.h @@ -45,6 +45,7 @@ QT_BEGIN_NAMESPACE class QGamepadBackend; class QGamepad; +class QGamepadManagerPrivate; class Q_GAMEPAD_EXPORT QGamepadManager : public QObject { @@ -88,11 +89,11 @@ public: static QGamepadManager* instance(); - bool isGamepadConnected(int deviceId); + bool isGamepadConnected(int deviceId) const; const QList connectedGamepads() const; public Q_SLOTS: - bool isConfigurationNeeded(int deviceId); + bool isConfigurationNeeded(int deviceId) const; bool configureButton(int deviceId, GamepadButton button); bool configureAxis(int deviceId, GamepadAxis axis); bool setCancelConfigureButton(int deviceId, GamepadButton button); @@ -110,24 +111,17 @@ Q_SIGNALS: void axisConfigured(int deviceId, QGamepadManager::GamepadAxis axis); void configurationCanceled(int deviceId); -private Q_SLOTS: - void forwardGamepadConnected(int deviceId); - void forwardGamepadDisconnected(int deviceId); - void forwardGamepadAxisEvent(int deviceId, QGamepadManager::GamepadAxis axis, double value); - void forwardGamepadButtonPressEvent(int deviceId, QGamepadManager::GamepadButton button, double value); - void forwardGamepadButtonReleaseEvent(int deviceId, QGamepadManager::GamepadButton button); - private: QGamepadManager(); ~QGamepadManager(); - QGamepadManager(QGamepadManager const&); - void operator=(QGamepadManager const&); - - void loadBackend(); - - QGamepadBackend *m_gamepadBackend; - QSet m_connectedGamepads; + Q_DECLARE_PRIVATE(QGamepadManager) + Q_DISABLE_COPY(QGamepadManager) + Q_PRIVATE_SLOT(d_func(), void _q_forwardGamepadConnected(int)) + Q_PRIVATE_SLOT(d_func(), void _q_forwardGamepadDisconnected(int)) + Q_PRIVATE_SLOT(d_func(), void _q_forwardGamepadAxisEvent(int, QGamepadManager::GamepadAxis, double)) + Q_PRIVATE_SLOT(d_func(), void _q_forwardGamepadButtonPressEvent(int, QGamepadManager::GamepadButton, double)) + Q_PRIVATE_SLOT(d_func(), void _q_forwardGamepadButtonReleaseEvent(int, QGamepadManager::GamepadButton)) }; QT_END_NAMESPACE -- cgit v1.2.3 From 38c99df55648bb13c0d1c761413c639ba8e0ad26 Mon Sep 17 00:00:00 2001 From: Andy Nichols Date: Tue, 31 Jan 2017 11:33:13 +0100 Subject: General Module Cleanups Removed reference to bsquask nullptr instead of 0 explicit override keyword for virtuals Q_SLOTS and Q_SIGNALS instead of keywords Change-Id: I7dd96fa66003c52fe2d26decca73224b70896baa Reviewed-by: Laszlo Agocs --- src/gamepad/qgamepadbackend_p.h | 6 +++--- src/gamepad/qgamepadbackendplugin_p.h | 4 ++-- src/gamepad/qgamepadkeynavigation.cpp | 2 +- src/gamepad/qgamepadmanager.cpp | 2 +- src/imports/gamepad/qgamepadmouseitem.cpp | 2 +- src/imports/gamepad/qgamepadmouseitem.h | 2 +- src/plugins/gamepads/android/src/main.cpp | 2 +- .../gamepads/android/src/qandroidgamepadbackend_p.h | 2 +- src/plugins/gamepads/darwin/main.cpp | 2 +- src/plugins/gamepads/darwin/qdarwingamepadbackend_p.h | 8 ++++---- src/plugins/gamepads/evdev/main.cpp | 2 +- src/plugins/gamepads/evdev/qevdevgamepadbackend_p.h | 16 ++++++++-------- src/plugins/gamepads/sdl2/main.cpp | 2 +- src/plugins/gamepads/sdl2/qsdlgamepadbackend_p.h | 8 ++++---- src/plugins/gamepads/xinput/main.cpp | 2 +- src/plugins/gamepads/xinput/qxinputgamepadbackend.cpp | 2 +- src/plugins/gamepads/xinput/qxinputgamepadbackend_p.h | 4 ++-- 17 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/gamepad/qgamepadbackend_p.h b/src/gamepad/qgamepadbackend_p.h index 0d1f0a6..0ce46de 100644 --- a/src/gamepad/qgamepadbackend_p.h +++ b/src/gamepad/qgamepadbackend_p.h @@ -83,7 +83,7 @@ public: }; public: - explicit QGamepadBackend(QObject *parent = 0); + explicit QGamepadBackend(QObject *parent = nullptr); virtual bool isConfigurationNeeded(int deviceId); virtual void resetConfiguration(int deviceId); virtual bool configureButton(int deviceId, QGamepadManager::GamepadButton button); @@ -93,11 +93,11 @@ public: virtual void saveSettings(int productId, const QVariant &value); virtual QVariant readSettings(int productId); -public slots: +public Q_SLOTS: virtual bool start(); virtual void stop(); -signals: +Q_SIGNALS: void buttonConfigured(int deviceId, QGamepadManager::GamepadButton button); void axisConfigured(int deviceId, QGamepadManager::GamepadAxis axis); void configurationCanceled(int deviceId); diff --git a/src/gamepad/qgamepadbackendplugin_p.h b/src/gamepad/qgamepadbackendplugin_p.h index 6bb680f..19f53c8 100644 --- a/src/gamepad/qgamepadbackendplugin_p.h +++ b/src/gamepad/qgamepadbackendplugin_p.h @@ -57,13 +57,13 @@ QT_BEGIN_NAMESPACE class QGamepadBackend; -#define QtGamepadBackendFactoryInterface_iid "com.bsquask.Qt.Gamepad.QtGamepadBackendFactoryInterface.5.5" +#define QtGamepadBackendFactoryInterface_iid "org.qt-project.Qt.Gamepad.QtGamepadBackendFactoryInterface.5.9" class Q_GAMEPAD_EXPORT QGamepadBackendPlugin : public QObject { Q_OBJECT public: - explicit QGamepadBackendPlugin(QObject *parent = 0); + explicit QGamepadBackendPlugin(QObject *parent = nullptr); ~QGamepadBackendPlugin(); virtual QGamepadBackend *create(const QString &key, const QStringList ¶mList) = 0; diff --git a/src/gamepad/qgamepadkeynavigation.cpp b/src/gamepad/qgamepadkeynavigation.cpp index a317ed0..2eac092 100644 --- a/src/gamepad/qgamepadkeynavigation.cpp +++ b/src/gamepad/qgamepadkeynavigation.cpp @@ -76,7 +76,7 @@ void QGamepadKeyNavigationPrivate::sendGeneratedKeyEvent(QKeyEvent *event) return; } const QGuiApplication *app = qApp; - QWindow *focusWindow = app ? app->focusWindow() : 0; + QWindow *focusWindow = app ? app->focusWindow() : nullptr; if (focusWindow) QGuiApplication::sendEvent(focusWindow, event); } diff --git a/src/gamepad/qgamepadmanager.cpp b/src/gamepad/qgamepadmanager.cpp index 51912ad..4d5c596 100644 --- a/src/gamepad/qgamepadmanager.cpp +++ b/src/gamepad/qgamepadmanager.cpp @@ -127,7 +127,7 @@ void QGamepadManagerPrivate::loadBackend() } QGamepadManager::QGamepadManager() : - QObject(*new QGamepadManagerPrivate(), 0) + QObject(*new QGamepadManagerPrivate(), nullptr) { Q_D(QGamepadManager); diff --git a/src/imports/gamepad/qgamepadmouseitem.cpp b/src/imports/gamepad/qgamepadmouseitem.cpp index b8144d7..a7a4a17 100644 --- a/src/imports/gamepad/qgamepadmouseitem.cpp +++ b/src/imports/gamepad/qgamepadmouseitem.cpp @@ -47,7 +47,7 @@ QT_BEGIN_NAMESPACE QGamepadMouseItem::QGamepadMouseItem(QQuickItem *parent) : QQuickItem(parent) , m_active(false) - , m_gamepad(0) + , m_gamepad(nullptr) , m_joystick(QGamepadMouseItem::LeftStick) , m_deadZoneSize(0.1) { diff --git a/src/imports/gamepad/qgamepadmouseitem.h b/src/imports/gamepad/qgamepadmouseitem.h index d5eb1e7..b58d9e1 100644 --- a/src/imports/gamepad/qgamepadmouseitem.h +++ b/src/imports/gamepad/qgamepadmouseitem.h @@ -62,7 +62,7 @@ public: Both }; - explicit QGamepadMouseItem(QQuickItem *parent = 0); + explicit QGamepadMouseItem(QQuickItem *parent = nullptr); bool active() const; QGamepad* gamepad() const; diff --git a/src/plugins/gamepads/android/src/main.cpp b/src/plugins/gamepads/android/src/main.cpp index 20cc646..ddd9261 100644 --- a/src/plugins/gamepads/android/src/main.cpp +++ b/src/plugins/gamepads/android/src/main.cpp @@ -46,7 +46,7 @@ class QAndroidGamepadBackendPlugin : public QGamepadBackendPlugin Q_OBJECT Q_PLUGIN_METADATA(IID QtGamepadBackendFactoryInterface_iid FILE "android.json") public: - QGamepadBackend *create(const QString &key, const QStringList ¶mList) Q_DECL_OVERRIDE; + QGamepadBackend *create(const QString &key, const QStringList ¶mList) override; }; QGamepadBackend *QAndroidGamepadBackendPlugin::create(const QString &key, const QStringList ¶mList) { diff --git a/src/plugins/gamepads/android/src/qandroidgamepadbackend_p.h b/src/plugins/gamepads/android/src/qandroidgamepadbackend_p.h index 4ef6552..fdd1619 100644 --- a/src/plugins/gamepads/android/src/qandroidgamepadbackend_p.h +++ b/src/plugins/gamepads/android/src/qandroidgamepadbackend_p.h @@ -53,7 +53,7 @@ class QAndroidGamepadBackend : public QGamepadBackend, public QtAndroidPrivate:: { Q_OBJECT public: - explicit QAndroidGamepadBackend(QObject *parent = 0); + explicit QAndroidGamepadBackend(QObject *parent = nullptr); ~QAndroidGamepadBackend(); void addDevice(int deviceId); diff --git a/src/plugins/gamepads/darwin/main.cpp b/src/plugins/gamepads/darwin/main.cpp index f1dc667..0eb4dff 100644 --- a/src/plugins/gamepads/darwin/main.cpp +++ b/src/plugins/gamepads/darwin/main.cpp @@ -46,7 +46,7 @@ class QDarwinGamepadBackendPlugin : public QGamepadBackendPlugin Q_OBJECT Q_PLUGIN_METADATA(IID QtGamepadBackendFactoryInterface_iid FILE "darwin.json") public: - QGamepadBackend *create(const QString &key, const QStringList ¶mList) Q_DECL_OVERRIDE; + QGamepadBackend *create(const QString &key, const QStringList ¶mList) override; }; QGamepadBackend *QDarwinGamepadBackendPlugin::create(const QString &key, const QStringList ¶mList) { diff --git a/src/plugins/gamepads/darwin/qdarwingamepadbackend_p.h b/src/plugins/gamepads/darwin/qdarwingamepadbackend_p.h index 632d5b3..8b21a15 100644 --- a/src/plugins/gamepads/darwin/qdarwingamepadbackend_p.h +++ b/src/plugins/gamepads/darwin/qdarwingamepadbackend_p.h @@ -51,14 +51,14 @@ class QDarwinGamepadBackend : public QGamepadBackend { Q_OBJECT public: - explicit QDarwinGamepadBackend(QObject *parent = 0); + explicit QDarwinGamepadBackend(QObject *parent = nullptr); ~QDarwinGamepadBackend(); protected: - bool start(); - void stop(); + bool start() override; + void stop() override; -public slots: +public Q_SLOTS: void darwinGamepadAdded(int index); void darwinGamepadRemoved(int index); void darwinGamepadAxisMoved(int index, QGamepadManager::GamepadAxis axis, double value); diff --git a/src/plugins/gamepads/evdev/main.cpp b/src/plugins/gamepads/evdev/main.cpp index 64f6952..7c6ce57 100644 --- a/src/plugins/gamepads/evdev/main.cpp +++ b/src/plugins/gamepads/evdev/main.cpp @@ -46,7 +46,7 @@ class QEvdevGamepadBackendPlugin : public QGamepadBackendPlugin Q_OBJECT Q_PLUGIN_METADATA(IID QtGamepadBackendFactoryInterface_iid FILE "evdev.json") public: - QGamepadBackend *create(const QString &key, const QStringList ¶mList) Q_DECL_OVERRIDE; + QGamepadBackend *create(const QString &key, const QStringList ¶mList) override; }; QGamepadBackend *QEvdevGamepadBackendPlugin::create(const QString &key, const QStringList ¶mList) diff --git a/src/plugins/gamepads/evdev/qevdevgamepadbackend_p.h b/src/plugins/gamepads/evdev/qevdevgamepadbackend_p.h index 2b3f72a..68e011c 100644 --- a/src/plugins/gamepads/evdev/qevdevgamepadbackend_p.h +++ b/src/plugins/gamepads/evdev/qevdevgamepadbackend_p.h @@ -65,7 +65,7 @@ public: bool configureAxis(QGamepadManager::GamepadAxis axis); bool setCancelConfigureButton(QGamepadManager::GamepadButton button); -private slots: +private Q_SLOTS: void readData(); private: @@ -113,13 +113,13 @@ class QEvdevGamepadBackend : public QGamepadBackend public: QEvdevGamepadBackend(); - bool start() Q_DECL_OVERRIDE; - void stop() Q_DECL_OVERRIDE; - void resetConfiguration(int deviceId) Q_DECL_OVERRIDE; - bool isConfigurationNeeded(int deviceId) Q_DECL_OVERRIDE; - bool configureButton(int deviceId, QGamepadManager::GamepadButton button) Q_DECL_OVERRIDE; - bool configureAxis(int deviceId, QGamepadManager::GamepadAxis axis) Q_DECL_OVERRIDE; - bool setCancelConfigureButton(int deviceId, QGamepadManager::GamepadButton button) Q_DECL_OVERRIDE; + bool start() override; + void stop() override; + void resetConfiguration(int deviceId) override; + bool isConfigurationNeeded(int deviceId) override; + bool configureButton(int deviceId, QGamepadManager::GamepadButton button) override; + bool configureAxis(int deviceId, QGamepadManager::GamepadAxis axis) override; + bool setCancelConfigureButton(int deviceId, QGamepadManager::GamepadButton button) override; private slots: void handleAddedDevice(const QString &device); diff --git a/src/plugins/gamepads/sdl2/main.cpp b/src/plugins/gamepads/sdl2/main.cpp index cc28ad2..a2adf69 100644 --- a/src/plugins/gamepads/sdl2/main.cpp +++ b/src/plugins/gamepads/sdl2/main.cpp @@ -46,7 +46,7 @@ class QSdl2GamepadBackendPlugin : public QGamepadBackendPlugin Q_OBJECT Q_PLUGIN_METADATA(IID QtGamepadBackendFactoryInterface_iid FILE "sdl2.json") public: - QGamepadBackend *create(const QString &key, const QStringList ¶mList) Q_DECL_OVERRIDE; + QGamepadBackend *create(const QString &key, const QStringList ¶mList) override; }; QGamepadBackend *QSdl2GamepadBackendPlugin::create(const QString &key, const QStringList ¶mList) { diff --git a/src/plugins/gamepads/sdl2/qsdlgamepadbackend_p.h b/src/plugins/gamepads/sdl2/qsdlgamepadbackend_p.h index 5991ac1..daff498 100644 --- a/src/plugins/gamepads/sdl2/qsdlgamepadbackend_p.h +++ b/src/plugins/gamepads/sdl2/qsdlgamepadbackend_p.h @@ -51,15 +51,15 @@ class QSdlGamepadBackend : public QGamepadBackend { Q_OBJECT public: - explicit QSdlGamepadBackend(QObject *parent = 0); + explicit QSdlGamepadBackend(QObject *parent = nullptr); ~QSdlGamepadBackend(); -private slots: +private Q_SLOTS: void pumpSdlEventLoop(); protected: - bool start(); - void stop(); + bool start() override; + void stop() override; private: QGamepadManager::GamepadButton translateButton(int button); diff --git a/src/plugins/gamepads/xinput/main.cpp b/src/plugins/gamepads/xinput/main.cpp index a5eb0f8..28ce133 100644 --- a/src/plugins/gamepads/xinput/main.cpp +++ b/src/plugins/gamepads/xinput/main.cpp @@ -46,7 +46,7 @@ class QXInputGamepadBackendPlugin : public QGamepadBackendPlugin Q_OBJECT Q_PLUGIN_METADATA(IID QtGamepadBackendFactoryInterface_iid FILE "xinput.json") public: - QGamepadBackend *create(const QString &key, const QStringList ¶mList) Q_DECL_OVERRIDE; + QGamepadBackend *create(const QString &key, const QStringList ¶mList) override; }; QGamepadBackend *QXInputGamepadBackendPlugin::create(const QString &key, const QStringList ¶mList) diff --git a/src/plugins/gamepads/xinput/qxinputgamepadbackend.cpp b/src/plugins/gamepads/xinput/qxinputgamepadbackend.cpp index 97680cb..e9a04a4 100644 --- a/src/plugins/gamepads/xinput/qxinputgamepadbackend.cpp +++ b/src/plugins/gamepads/xinput/qxinputgamepadbackend.cpp @@ -91,7 +91,7 @@ class QXInputThread : public QThread { public: QXInputThread(QXInputGamepadBackend *backend); - void run() Q_DECL_OVERRIDE; + void run() override; void signalQuit() { m_quit.fetchAndStoreAcquire(1); } private: diff --git a/src/plugins/gamepads/xinput/qxinputgamepadbackend_p.h b/src/plugins/gamepads/xinput/qxinputgamepadbackend_p.h index 42f7a4a..b575ca1 100644 --- a/src/plugins/gamepads/xinput/qxinputgamepadbackend_p.h +++ b/src/plugins/gamepads/xinput/qxinputgamepadbackend_p.h @@ -50,8 +50,8 @@ class QXInputGamepadBackend : public QGamepadBackend public: QXInputGamepadBackend(); - bool start() Q_DECL_OVERRIDE; - void stop() Q_DECL_OVERRIDE; + bool start() override; + void stop() override; private: QXInputThread *m_thread; -- cgit v1.2.3