Add ThemeEngine class

Author: adazem009

src/ui/CMakeLists.txt

@@ -4,8 +4,11 @@ set(MODULE_SRC
  uimodule.cpp
  uimodule.h
  iuiengine.h
+ ithemeengine.h
  internal/uiengine.cpp
  internal/uiengine.h
+ internal/themeengine.cpp
+ internal/themeengine.h
 )
 
 include(${PROJECT_SOURCE_DIR}/build/module.cmake)

src/ui/internal/themeengine.cpp

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "themeengine.h"
+#include "isettings.h"
+
+using namespace scratchcpp;
+
+static const QString MODULE = "ui";
+static const QString THEME_KEY = "theme";
+
+std::shared_ptr<ThemeEngine> ThemeEngine::m_instance = std::make_shared<ThemeEngine>();
+
+std::shared_ptr<ThemeEngine> ThemeEngine::instance()
+{
+ return m_instance;
+}
+
+IThemeEngine::Theme ThemeEngine::theme() const
+{
+ return static_cast<Theme>(settings()->getValue(MODULE, THEME_KEY).toInt());
+}
+
+void ThemeEngine::setTheme(Theme newTheme)
+{
+ settings()->setValue(MODULE, THEME_KEY, static_cast<int>(newTheme));
+ reloadTheme();
+}
+
+void ThemeEngine::reloadTheme()
+{
+ emit bgColorChanged();
+ emit borderColorChanged();
+ emit themeChanged();
+}
+
+void ThemeEngine::resetTheme()
+{
+ setTheme(Theme::DarkTheme);
+}
+
+const QColor &ThemeEngine::bgColor() const
+{
+ static const QColor dark = QColor(31, 30, 28);
+ static const QColor light = QColor(255, 255, 255);
+ return theme() == Theme::DarkTheme ? dark : light;
+}
+
+const QColor &ThemeEngine::borderColor() const
+{
+ static const QColor dark = QColor(255, 255, 255, 64);
+ static const QColor light = QColor(0, 0, 0, 64);
+ return theme() == Theme::DarkTheme ? dark : light;
+}

src/ui/internal/themeengine.h

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QColor>
+
+#include "ithemeengine.h"
+
+Q_MOC_INCLUDE("isettings.h")
+
+namespace scratchcpp
+{
+
+class ISettings;
+
+class ThemeEngine : public IThemeEngine
+{
+ Q_OBJECT
+ INJECT(ISettings, settings)
+ Q_PROPERTY(Theme theme READ theme WRITE setTheme NOTIFY themeChanged FINAL)
+ Q_PROPERTY(QColor bgColor READ bgColor NOTIFY bgColorChanged FINAL)
+ Q_PROPERTY(QColor borderColor READ borderColor NOTIFY borderColorChanged FINAL)
+ public:
+ static std::shared_ptr<ThemeEngine> instance();
+
+ Theme theme() const override;
+ void setTheme(Theme newTheme) override;
+ Q_INVOKABLE void reloadTheme() override;
+ Q_INVOKABLE void resetTheme() override;
+
+ const QColor &bgColor() const override;
+ const QColor &borderColor() const override;
+
+ signals:
+ void themeChanged();
+ void bgColorChanged();
+ void borderColorChanged();
+
+ private:
+ static std::shared_ptr<ThemeEngine> m_instance;
+};
+
+} // namespace scratchcpp

src/ui/ithemeengine.h

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QObject>
+
+#include "modularity/ioc.h"
+
+namespace scratchcpp
+{
+
+class IThemeEngine
+ : public QObject
+ , MODULE_EXPORT_INTERFACE
+{
+ Q_OBJECT
+ public:
+ virtual ~IThemeEngine() { }
+
+ enum class Theme
+ {
+ LightTheme = 1,
+ DarkTheme = 0
+ };
+ Q_ENUM(Theme)
+
+ virtual Theme theme() const = 0;
+ virtual void setTheme(Theme newTheme) = 0;
+ virtual void reloadTheme() = 0;
+ virtual void resetTheme() = 0;
+
+ virtual const QColor &bgColor() const = 0;
+ virtual const QColor &borderColor() const = 0;
+};
+
+} // namespace scratchcpp

src/ui/test/CMakeLists.txt

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

src/ui/test/mocks/settingsmock.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <isettings.h>
+#include <gmock/gmock.h>
+
+namespace scratchcpp
+{
+
+class SettingsMock : public ISettings
+{
+ public:
+ MOCK_METHOD(void, addKey, (const QString &, const QString &, const QVariant &), (override));
+ MOCK_METHOD(void, setValue, (const QString &, const QString &, const QVariant &), (override));
+ MOCK_METHOD(QVariant, getValue, (const QString &, const QString &), (const, override));
+ MOCK_METHOD(bool, containsKey, (const QString &, const QString &), (const, override));
+
+ MOCK_METHOD(void, freeze, (), (override));
+ MOCK_METHOD(void, saveChanges, (), (override));
+ MOCK_METHOD(void, discardChanges, (), (override));
+ MOCK_METHOD(bool, isFrozen, (), (const, override));
+};
+
+} // namespace scratchcpp

src/ui/test/themeengine.cpp

@@ -0,0 +1,71 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <QSignalSpy>
+
+#include "mocks/settingsmock.h"
+
+#include "internal/themeengine.h"
+
+using namespace scratchcpp;
+
+using ::testing::Return;
+using ::testing::_;
+
+static const QString MODULE = "ui";
+static const QString THEME_KEY = "theme";
+
+class ThemeEngineTest : public testing::Test
+{
+ public:
+ void SetUp() override
+ {
+ m_settings = std::make_shared<SettingsMock>();
+ m_themeEngine.setsettings(m_settings);
+
+ m_themeSpies.push_back(std::make_unique<QSignalSpy>(&m_themeEngine, &ThemeEngine::themeChanged));
+ m_themeSpies.push_back(std::make_unique<QSignalSpy>(&m_themeEngine, &ThemeEngine::bgColorChanged));
+ m_themeSpies.push_back(std::make_unique<QSignalSpy>(&m_themeEngine, &ThemeEngine::borderColorChanged));
+ }
+
+ void TearDown() override { m_themeEngine.setsettings(nullptr); }
+
+ void checkThemeSpies(int count)
+ {
+ for (const auto &spy : m_themeSpies)
+ ASSERT_EQ(spy->count(), count);
+ }
+
+ ThemeEngine m_themeEngine;
+ std::shared_ptr<SettingsMock> m_settings;
+ std::vector<std::unique_ptr<QSignalSpy>> m_themeSpies;
+};
+
+TEST_F(ThemeEngineTest, Instance)
+{
+ ASSERT_TRUE(ThemeEngine::instance());
+}
+
+TEST_F(ThemeEngineTest, Theme)
+{
+ EXPECT_CALL(*m_settings, getValue(MODULE, THEME_KEY)).WillOnce(Return(0));
+ ASSERT_EQ(m_themeEngine.theme(), ThemeEngine::Theme::DarkTheme);
+
+ EXPECT_CALL(*m_settings, getValue(MODULE, THEME_KEY)).WillOnce(Return(1));
+ ASSERT_EQ(m_themeEngine.theme(), ThemeEngine::Theme::LightTheme);
+ checkThemeSpies(0);
+
+ EXPECT_CALL(*m_settings, setValue(MODULE, THEME_KEY, QVariant(0)));
+ m_themeEngine.setTheme(ThemeEngine::Theme::DarkTheme);
+ checkThemeSpies(1);
+
+ EXPECT_CALL(*m_settings, setValue(MODULE, THEME_KEY, QVariant(1)));
+ m_themeEngine.setTheme(ThemeEngine::Theme::LightTheme);
+ checkThemeSpies(2);
+
+ EXPECT_CALL(*m_settings, setValue(MODULE, THEME_KEY, _));
+ m_themeEngine.resetTheme();
+ checkThemeSpies(3);
+
+ m_themeEngine.reloadTheme();
+ checkThemeSpies(4);
+}

src/ui/uimodule.cpp

@@ -3,7 +3,9 @@
 #include <QQmlEngine>
 
 #include "uimodule.h"
+#include "isettings.h"
 #include "internal/uiengine.h"
+#include "internal/themeengine.h"
 
 using namespace scratchcpp::ui;
 
@@ -21,4 +23,13 @@ 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());
+
+ QQmlEngine::setObjectOwnership(ThemeEngine::instance().get(), QQmlEngine::CppOwnership);
+ qmlRegisterSingletonInstance<ThemeEngine>("ScratchCPP.Ui", 1, 0, "ThemeEngine", ThemeEngine::instance().get());
+ modularity::ioc()->registerExport<IThemeEngine>(ThemeEngine::instance());
+}
+
+void UiModule::initSettings()
+{
+ INIT_SETTINGS_KEY("theme", static_cast<int>(IThemeEngine::Theme::DarkTheme));
 }

src/ui/uimodule.h

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