PImplize the public exports

QGamepad, QGamepadManager, and QGamepadKeyNavigation needed private
implementations.

Change-Id: I592933f2b8a3101f0a7b9eeaf789e6ac8e2bc15b
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

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 <private/qobject_p.h>
+
 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 <QtGui/QWindow>
 #include <QtGamepad/QGamepad>
 
+#include <private/qobject_p.h>
+
 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<QGamepadManager::GamepadButton, Qt::Key> 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<QGamepadManager::GamepadButton, Qt::Key> 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 <QtCore/QLoggingCategory>
 
+#include <private/qobject_p.h>
+
 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>("QGamepadManager::GamepadButton");
-    qRegisterMetaType<QGamepadManager::GamepadAxis>("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<int> 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>("QGamepadManager::GamepadButton");
+    qRegisterMetaType<QGamepadManager::GamepadAxis>("QGamepadManager::GamepadAxis");
 
-const QList<int> 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<int> 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<int> 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<int> 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