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