Merge pull request #46 from scratchcpp/key_press_events

Handle key events

Author: adazem009

ScratchCPPGui/CMakeLists.txt

@@ -22,4 +22,6 @@ qt_add_qml_module(libscratchcpp-gui
         renderedtarget.h
 	targetpainter.cpp
 	targetpainter.h
+	keyeventhandler.cpp
+	keyeventhandler.h
 )

ScratchCPPGui/keyeventhandler.cpp

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include <QKeyEvent>
+
+#include "keyeventhandler.h"
+
+using namespace scratchcppgui;
+
+KeyEventHandler::KeyEventHandler(QObject *parent) :
+    QObject(parent)
+{
+}
+
+bool KeyEventHandler::eventFilter(QObject *obj, QEvent *event)
+{
+    switch (event->type()) {
+        case QEvent::KeyPress: {
+            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
+            emit keyPressed(static_cast<Qt::Key>(keyEvent->key()), keyEvent->text());
+            break;
+        }
+
+        case QEvent::KeyRelease: {
+            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
+            emit keyReleased(static_cast<Qt::Key>(keyEvent->key()), keyEvent->text());
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    return QObject::eventFilter(obj, event);
+}

ScratchCPPGui/keyeventhandler.h

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <QObject>
+
+namespace scratchcppgui
+{
+
+class KeyEventHandler : public QObject
+{
+        Q_OBJECT
+    public:
+        explicit KeyEventHandler(QObject *parent = nullptr);
+
+    signals:
+        void keyPressed(Qt::Key key, const QString &text);
+        void keyReleased(Qt::Key key, const QString &text);
+
+    protected:
+        bool eventFilter(QObject *obj, QEvent *event) override;
+};
+
+} // namespace scratchcppgui

ScratchCPPGui/projectscene.cpp

@@ -1,22 +1,34 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
+#include <QQuickWindow>
 #include <scratchcpp/iengine.h>
+#include <scratchcpp/keyevent.h>
 
 #include "projectscene.h"
+#include "keyeventhandler.h"
 
-namespace scratchcppgui
-{
+using namespace scratchcppgui;
+using namespace libscratchcpp;
+
+static const std::unordered_map<Qt::Key, KeyEvent::Type> SPECIAL_KEY_MAP = {
+    { Qt::Key_Space, KeyEvent::Type::Space }, { Qt::Key_Left, KeyEvent::Type::Left },    { Qt::Key_Up, KeyEvent::Type::Up },      { Qt::Key_Right, KeyEvent::Type::Right },
+    { Qt::Key_Down, KeyEvent::Type::Down },   { Qt::Key_Return, KeyEvent::Type::Enter }, { Qt::Key_Enter, KeyEvent::Type::Enter }
+};
 
 ProjectScene::ProjectScene(QQuickItem *parent)
 {
+    m_keyHandler = new KeyEventHandler(this);
+    connect(this, &QQuickItem::windowChanged, this, &ProjectScene::installKeyHandler);
+    connect(m_keyHandler, &KeyEventHandler::keyPressed, this, &ProjectScene::handleKeyPress);
+    connect(m_keyHandler, &KeyEventHandler::keyReleased, this, &ProjectScene::handleKeyRelease);
 }
 
-libscratchcpp::IEngine *ProjectScene::engine() const
+IEngine *ProjectScene::engine() const
 {
     return m_engine;
 }
 
-void ProjectScene::setEngine(libscratchcpp::IEngine *newEngine)
+void ProjectScene::setEngine(IEngine *newEngine)
 {
     if (m_engine == newEngine)
         return;
@@ -45,4 +57,36 @@ void ProjectScene::handleMouseRelease()
         m_engine->setMousePressed(false);
 }
 
-} // namespace scratchcppgui
+void ProjectScene::handleKeyPress(Qt::Key key, const QString &text)
+{
+    if (m_engine) {
+        auto it = SPECIAL_KEY_MAP.find(key);
+
+        if (it == SPECIAL_KEY_MAP.cend())
+            m_engine->setKeyState(text.toStdString(), true);
+        else {
+            KeyEvent event(it->second);
+            m_engine->setKeyState(event.name(), true);
+        }
+    }
+}
+
+void ProjectScene::handleKeyRelease(Qt::Key key, const QString &text)
+{
+    if (m_engine) {
+        auto it = SPECIAL_KEY_MAP.find(key);
+
+        if (it == SPECIAL_KEY_MAP.cend())
+            m_engine->setKeyState(text.toStdString(), false);
+        else {
+            KeyEvent event(it->second);
+            m_engine->setKeyState(event.name(), false);
+        }
+    }
+}
+
+void ProjectScene::installKeyHandler(QQuickWindow *window)
+{
+    if (window)
+        window->installEventFilter(m_keyHandler);
+}

ScratchCPPGui/projectscene.h

@@ -12,6 +12,8 @@ class IEngine;
 namespace scratchcppgui
 {
 
+class KeyEventHandler;
+
 class ProjectScene : public QQuickItem
 {
         Q_OBJECT
@@ -28,11 +30,17 @@ class ProjectScene : public QQuickItem
         Q_INVOKABLE void handleMousePress();
         Q_INVOKABLE void handleMouseRelease();
 
+        void handleKeyPress(Qt::Key key, const QString &text);
+        void handleKeyRelease(Qt::Key key, const QString &text);
+
     signals:
         void engineChanged();
 
     private:
+        void installKeyHandler(QQuickWindow *window);
+
         libscratchcpp::IEngine *m_engine = nullptr;
+        KeyEventHandler *m_keyHandler = nullptr;
 };
 
 } // namespace scratchcppgui

test/projectscene/projectscene_test.cpp

@@ -1,3 +1,4 @@
+#include <scratchcpp/keyevent.h>
 #include <projectscene.h>
 #include <enginemock.h>
 
@@ -55,3 +56,36 @@ TEST(ProjectScene, HandleMouseRelease)
     EXPECT_CALL(engine, setMousePressed(false));
     scene.handleMouseRelease();
 }
+
+TEST(ProjectScene, HandleKeyPressAndRelease)
+{
+    static const std::unordered_map<Qt::Key, KeyEvent::Type> SPECIAL_KEY_MAP = {
+        { Qt::Key_Space, KeyEvent::Type::Space }, { Qt::Key_Left, KeyEvent::Type::Left },    { Qt::Key_Up, KeyEvent::Type::Up },      { Qt::Key_Right, KeyEvent::Type::Right },
+        { Qt::Key_Down, KeyEvent::Type::Down },   { Qt::Key_Return, KeyEvent::Type::Enter }, { Qt::Key_Enter, KeyEvent::Type::Enter }
+    };
+
+    ProjectScene scene;
+    EngineMock engine;
+    scene.setEngine(&engine);
+
+    for (const auto &[qtKey, scratchKey] : SPECIAL_KEY_MAP) {
+        KeyEvent event(scratchKey);
+        EXPECT_CALL(engine, setKeyState(event.name(), true));
+        scene.handleKeyPress(qtKey, "test");
+
+        EXPECT_CALL(engine, setKeyState(event.name(), false));
+        scene.handleKeyRelease(qtKey, "test");
+    }
+
+    EXPECT_CALL(engine, setKeyState("a", true));
+    scene.handleKeyPress(Qt::Key_A, "a");
+
+    EXPECT_CALL(engine, setKeyState("a", false));
+    scene.handleKeyRelease(Qt::Key_A, "a");
+
+    EXPECT_CALL(engine, setKeyState("0", true));
+    scene.handleKeyPress(Qt::Key_0, "0");
+
+    EXPECT_CALL(engine, setKeyState("0", false));
+    scene.handleKeyRelease(Qt::Key_0, "0");
+}