Add UiEngine class

Author: adazem009

src/app/app.cpp

@@ -9,6 +9,7 @@
 #include "app.h"
 #include "globalmodule.h"
 #include "modularity/ioc.h"
+#include "ui/internal/uiengine.h"
 
 using namespace scratchcpp;
 using namespace scratchcpp::modularity;
@@ -77,6 +78,8 @@ int App::run(int argc, char **argv)
         Qt::QueuedConnection);
     engine.load(url);
 
+    ui::UiEngine::instance()->setQmlEngine(&engine);
+
     // Run the event loop
     int exitCode = app.exec();
 

src/ui/CMakeLists.txt

@@ -3,6 +3,11 @@ set(MODULE_URI Ui)
 set(MODULE_SRC
     uimodule.cpp
     uimodule.h
+    iuiengine.h
+    internal/uiengine.cpp
+    internal/uiengine.h
 )
 
 include(${PROJECT_SOURCE_DIR}/build/module.cmake)
+
+add_subdirectory(test)

src/ui/internal/uiengine.cpp

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <QCoreApplication>
+#include <QPushButton>
+
+#include "uiengine.h"
+
+using namespace scratchcpp::ui;
+
+std::shared_ptr<UiEngine> UiEngine::m_instance = std::make_shared<UiEngine>();
+
+UiEngine::UiEngine(QObject *parent) :
+    QObject(parent)
+{
+}
+
+UiEngine::~UiEngine()
+{
+    if (m_dialogButtonBox)
+        m_dialogButtonBox->deleteLater();
+}
+
+std::shared_ptr<UiEngine> UiEngine::instance()
+{
+    return m_instance;
+}
+
+QQmlEngine *UiEngine::qmlEngine() const
+{
+    return m_qmlEngine;
+}
+
+void UiEngine::setQmlEngine(QQmlEngine *engine)
+{
+    m_qmlEngine = engine;
+}
+
+QString UiEngine::standardButtonText(QDialogButtonBox::StandardButton button) const
+{
+    if (!m_dialogButtonBox)
+        m_dialogButtonBox = new QDialogButtonBox; // construct on first use because widgets need QApplication
+
+    QPushButton *btn = m_dialogButtonBox->button(button);
+
+    if (!btn) {
+        m_dialogButtonBox->addButton(button);
+        btn = m_dialogButtonBox->button(button);
+    }
+
+    if (btn)
+        return btn->text();
+    else
+        return QString();
+}
+
+QQuickItem *UiEngine::activeFocusItem() const
+{
+    return m_activeFocusItem;
+}
+
+void UiEngine::setActiveFocusItem(QQuickItem *newActiveFocusItem)
+{
+    if (m_activeFocusItem == newActiveFocusItem)
+        return;
+
+    m_activeFocusItem = newActiveFocusItem;
+    emit activeFocusItemChanged();
+}

src/ui/internal/uiengine.h

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QObject>
+
+#include "ui/iuiengine.h"
+
+Q_MOC_INCLUDE(<QQuickItem>)
+
+class QQuickItem;
+
+namespace scratchcpp::ui
+{
+
+class UiEngine
+    : public QObject
+    , public IUiEngine
+{
+        Q_OBJECT
+        Q_PROPERTY(QQuickItem *activeFocusItem READ activeFocusItem WRITE setActiveFocusItem NOTIFY activeFocusItemChanged)
+
+    public:
+        explicit UiEngine(QObject *parent = nullptr);
+        ~UiEngine();
+
+        static std::shared_ptr<UiEngine> instance();
+
+        QQmlEngine *qmlEngine() const override;
+        void setQmlEngine(QQmlEngine *engine);
+
+        Q_INVOKABLE QString standardButtonText(QDialogButtonBox::StandardButton button) const override;
+
+        QQuickItem *activeFocusItem() const;
+        void setActiveFocusItem(QQuickItem *newActiveFocusItem);
+
+    signals:
+        void activeFocusItemChanged();
+
+    private:
+        static std::shared_ptr<UiEngine> m_instance;
+        QQmlEngine *m_qmlEngine = nullptr;
+        QQuickItem *m_activeFocusItem = nullptr;
+        mutable QDialogButtonBox *m_dialogButtonBox = nullptr;
+};
+
+} // namespace scratchcpp::ui

src/ui/iuiengine.h

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QDialogButtonBox>
+
+#include "modularity/ioc.h"
+
+class QQmlEngine;
+
+namespace scratchcpp::ui
+{
+
+class IUiEngine : MODULE_EXPORT_INTERFACE
+{
+    public:
+        virtual ~IUiEngine() { }
+
+        virtual QQmlEngine *qmlEngine() const = 0;
+
+        virtual QString standardButtonText(QDialogButtonBox::StandardButton button) const = 0;
+};
+
+} // namespace scratchcpp::ui

src/ui/test/CMakeLists.txt

@@ -0,0 +1,5 @@
+set(MODULE_TEST_SRC
+    uiengine.cpp
+)
+
+include(${PROJECT_SOURCE_DIR}/build/module_test.cmake)

src/ui/test/uiengine.cpp

@@ -0,0 +1,57 @@
+#include <gtest/gtest.h>
+#include <QQmlEngine>
+#include <QPushButton>
+#include <QQuickItem>
+#include <QSignalSpy>
+
+#include "internal/uiengine.h"
+
+using namespace scratchcpp::ui;
+
+TEST(UiEngineTest, Instance)
+{
+    ASSERT_TRUE(UiEngine::instance());
+}
+
+TEST(UiEngineTest, QmlEngine)
+{
+    UiEngine engine;
+    ASSERT_EQ(engine.qmlEngine(), nullptr);
+
+    QQmlEngine qmlEngine;
+    engine.setQmlEngine(&qmlEngine);
+    ASSERT_EQ(engine.qmlEngine(), &qmlEngine);
+}
+
+TEST(UiEngineTest, StandardButtonText)
+{
+    static const std::vector<QDialogButtonBox::StandardButton> buttons = {
+        QDialogButtonBox::Ok,       QDialogButtonBox::Open,    QDialogButtonBox::Save,
+        QDialogButtonBox::Cancel,   QDialogButtonBox::Close,   QDialogButtonBox::Discard,
+        QDialogButtonBox::Apply,    QDialogButtonBox::Reset,   QDialogButtonBox::RestoreDefaults,
+        QDialogButtonBox::Help,     QDialogButtonBox::SaveAll, QDialogButtonBox::Yes,
+        QDialogButtonBox::YesToAll, QDialogButtonBox::No,      QDialogButtonBox::NoToAll,
+        QDialogButtonBox::Abort,    QDialogButtonBox::Retry,   QDialogButtonBox::Ignore
+    };
+
+    UiEngine engine;
+    QDialogButtonBox dialogButtonBox;
+
+    for (QDialogButtonBox::StandardButton button : buttons) {
+        dialogButtonBox.addButton(button);
+        ASSERT_EQ(engine.standardButtonText(button), dialogButtonBox.button(button)->text());
+        ASSERT_FALSE(engine.standardButtonText(button).isEmpty());
+    }
+}
+
+TEST(UiEngineTest, ActiveFocusItem)
+{
+    UiEngine engine;
+    QSignalSpy spy(&engine, &UiEngine::activeFocusItemChanged);
+    ASSERT_EQ(engine.activeFocusItem(), nullptr);
+
+    QQuickItem item;
+    engine.setActiveFocusItem(&item);
+    ASSERT_EQ(engine.activeFocusItem(), &item);
+    ASSERT_EQ(spy.count(), 1);
+}

src/ui/uimodule.cpp

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include <QQmlEngine>
+
 #include "uimodule.h"
+#include "internal/uiengine.h"
 
 using namespace scratchcpp::ui;
 
@@ -12,3 +15,10 @@ std::string UiModule::moduleName() const
 {
     return "ui";
 }
+
+void scratchcpp::ui::UiModule::registerExports()
+{
+    QQmlEngine::setObjectOwnership(UiEngine::instance().get(), QQmlEngine::CppOwnership);
+    qmlRegisterSingletonInstance<UiEngine>("ScratchCPP.Ui", 1, 0, "UiEngine", UiEngine::instance().get());
+    modularity::ioc()->registerExport<IUiEngine>(UiEngine::instance());
+}

src/ui/uimodule.h

@@ -13,6 +13,8 @@ class UiModule : public modularity::IModuleSetup
         UiModule();
 
         std::string moduleName() const override;
+
+        void registerExports() override;
 };
 
 } // namespace scratchcpp::ui