GUIFramework.h

Go to the documentation of this file.

#pragma once
 
#include <future>
#include <shared_mutex>
#include <mutex>
#include <algorithm>
 
#include "Utility/Creators/BaseComponentCreator.h"
#include "Interfaces/Utility/IDeserializer.h"
#include "Utility/Keys.h"
#include "StringViewUtils.h"
 
#pragma comment (lib, "Comctl32.lib")
#pragma comment (lib, "UxTheme.lib")
 
#pragma comment (lib, "JSON.lib")
#pragma comment (lib, "ThreadPool.lib")
#pragma comment (lib, "Localization.lib")
 
namespace gui_framework
{
    class GUI_FRAMEWORK_API GUIFramework
    {
    public:
        struct GUI_FRAMEWORK_API hotkeyData
        {
            uint32_t key;
            std::function<void()> hotkeyEvent;
            std::string functionName;
            std::string moduleName;
            std::vector<hotkeys::additionalKeys> additionalKeys;
        
            hotkeyData();
 
            hotkeyData(uint32_t key, const std::function<void()>& hotkeyEvent, const std::vector<hotkeys::additionalKeys>& additionalKeys);
 
            hotkeyData(uint32_t key, const std::string& functionName, const std::string& moduleName, const std::vector<hotkeys::additionalKeys>& additionalKeys);
 
            hotkeyData(const hotkeyData&) = default;
 
            hotkeyData(hotkeyData&&) noexcept = default;
 
            hotkeyData& operator = (const hotkeyData&) = default;
 
            hotkeyData& operator = (hotkeyData&&) noexcept = default;
 
            ~hotkeyData() = default;
        };
 
    private:
        static std::unique_ptr<GUIFramework> instance;
 
    private:
        json::JSONParser jsonSettings;
        std::unique_ptr<threading::ThreadPool> threadPool;
        INITCOMMONCONTROLSEX comm;
        std::unordered_map<std::string, HMODULE, localization::utility::StringViewHash, localization::utility::StringViewEqual> modules;
        std::unordered_map<std::string, std::string> modulesPaths;
        std::unordered_map<size_t, smartPointerType<utility::BaseComponentCreator>> creators;
        std::unordered_map<size_t, smartPointerType<interfaces::IDeserializer>> deserializers;
        DWORD uiThreadId;
#pragma region Ids
        std::unordered_multimap<std::wstring, uint32_t> generatedIds;
        std::queue<uint32_t> availableIds;
        std::mutex idMutex;
        uint32_t nextId;
        std::atomic<uint32_t> nextTrayId;
#pragma endregion
#pragma region Hotkeys
        std::unordered_map<size_t, std::function<void()>> hotkeys;
        std::vector<std::set<uint32_t>> allHotkeys;
        std::unordered_map<size_t, hotkeyData> serializableHotkeysData;
        std::mutex hotkeyIdMutex;
#pragma endregion
#pragma region ComponentsFinding
        std::vector<BaseComponent*> components;
        std::recursive_mutex componentsMutex;
#pragma endregion
#pragma region Modules
        std::vector<std::unique_ptr<threading::Future>> asyncModulesHandles;
        std::mutex loadModulesMutex;
        std::vector<std::string> cantLoadedModules;
#pragma endregion
#pragma region RunOnUIThread
        std::recursive_mutex runOnUIThreadMutex;
        std::queue<std::function<void()>> runOnUIFunctions;
#pragma endregion
 
    private:
        void initCreators();
 
        void initDeserializers();
 
        void addComponent(BaseComponent* component);
 
        void removeComponent(BaseComponent* component);
 
    private:
        uint32_t generateId(std::wstring_view windowName);
 
        uint32_t generateTrayId();
 
        void removeIds(const std::wstring& windowName);
 
        void removeId(const std::wstring& windowName, uint32_t id);
 
        std::vector<uint32_t> getIds(const std::wstring& windowName);
 
        void processHotkeys() const;
 
        void initUIThreadId();
 
        void loadModule(const std::string& modulePath, const std::string& moduleName);
 
        void loadModulesFromSettings(const json::utility::jsonObject& settingsObject);
 
    private:
        GUIFramework();
 
        ~GUIFramework();
 
    public:
        static GUIFramework& get();
 
        static void runOnUIThread(const std::function<void()>& function);
 
        static void runOnUIThread(std::function<void()>&& function);
 
        static void restartApplication(int exitCode = 0);
 
        static DWORD getUIThreadId();
 
        static std::string getGUIFrameworkVersion();
 
    public:
        std::unique_ptr<threading::Future> addTask(const std::function<void()>& task, const std::function<void()>& callback = nullptr);
 
        std::unique_ptr<threading::Future> addTask(const std::function<void()>& task, std::function<void()>&& callback);
 
        std::unique_ptr<threading::Future> addTask(std::function<void()>&& task, const std::function<void()>& callback = nullptr);
 
        std::unique_ptr<threading::Future> addTask(std::function<void()>&& task, std::function<void()>&& callback);
 
        size_t registerHotkey(hotkeys::keys key, const std::function<void()>& onClick, const std::vector<hotkeys::additionalKeys>& additionalKeys = {});
 
        size_t registerHotkey(hotkeys::keys key, const std::string& functionName, const std::string& moduleName, const std::vector<hotkeys::additionalKeys>& additionalKeys = {});
 
        bool unregisterHotkey(size_t hotkeyId);
 
        bool unregisterHotkey(uint32_t key, const std::vector<hotkeys::additionalKeys>& additionalKeys = {});
 
        std::vector<hotkeyData> getRegisteredHotkeys();
 
        void loadModule(const std::string& moduleName, const std::filesystem::path& pathToModule);
 
        void unloadModule(const std::string& moduleName);
 
        bool isExist(BaseComponent* component);
 
        std::vector<json::utility::jsonObject> serializeHotkeys();
 
        void deserializeHotkeys(const json::utility::jsonObject& description);
 
        bool isModulesLoaded() const;
 
        void changeLocalization(const std::string& language) const;
 
        const std::unordered_map<size_t, smartPointerType<utility::BaseComponentCreator>>& getCreators() const;
 
        const std::unordered_map<size_t, smartPointerType<interfaces::IDeserializer>>& getDeserializers() const;
 
        const json::JSONParser& getJSONSettings() const;
 
        const std::unordered_map<std::string, HMODULE, localization::utility::StringViewHash, localization::utility::StringViewEqual>& getModules() const;
 
        const std::unordered_map<std::string, std::string>& getModulesPaths() const;
 
        std::vector<std::string> getCantLoadedModules();
 
        HMODULE operator [](const std::string& moduleName) const;
 
        template<typename T = BaseComponent>
        T* findComponent(HWND handle);
 
        template<typename T = BaseComponent>
        T* findComponent(const std::wstring& componentName);
 
        template<std::derived_from<BaseComponent> T, std::derived_from<utility::BaseComponentCreator> CreatorT, typename... Args>
        void addCreator(Args&&... args);
 
        template<std::derived_from<BaseComponent> T, std::derived_from<interfaces::IDeserializer> DeserializerT, typename... Args>
        void addDeserializer(Args&&... args);
#pragma region FriendClasses
        friend class BaseComponent;
        friend class WindowHolder;
        friend class BaseDialogBox;
        friend class BaseMainWindow;
        friend struct std::default_delete<GUIFramework>;
#pragma endregion
    };
 
    template<typename T>
    T* GUIFramework::findComponent(HWND handle)
    {
        std::unique_lock<std::recursive_mutex> lock(componentsMutex);
 
        auto it = std::ranges::find_if(components, [&handle](BaseComponent* component) { return component->getHandle() == handle; });
 
        return it == components.end() ? nullptr : dynamic_cast<T*>(*it);
    }
 
    template<typename T>
    T* GUIFramework::findComponent(const std::wstring& componentName)
    {
        std::unique_lock<std::recursive_mutex> lock(componentsMutex);
 
        auto it = std::ranges::find_if(components, [&componentName](BaseComponent* component) { return component->getWindowName() == componentName; });
 
        return it == components.end() ? nullptr : dynamic_cast<T*>(*it);
    }
 
    template<std::derived_from<BaseComponent> T, std::derived_from<utility::BaseComponentCreator> CreatorT, typename... Args>
    void GUIFramework::addCreator(Args&&... args)
    {
        creators[typeid(T).hash_code()] = smartPointerType<CreatorT>(new CreatorT(std::forward<Args>(args)...));
    }
 
    template<std::derived_from<BaseComponent> T, std::derived_from<interfaces::IDeserializer> DeserializerT, typename... Args>
    void GUIFramework::addDeserializer(Args&&... args)
    {
        deserializers[typeid(T).hash_code()] = smartPointerType<DeserializerT>(new DeserializerT(std::forward<Args>(args)...));
    }
}