application.h

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
//#if defined(_WIN32)
#include <imgui-platform-kit/user_interface.h>
//#elif defined(__linux__)
//#endif
 
#include "exceptions/exception.h"
#include "simulation/simulation.h"
#include "visualization/visualization.h"
 
#define IMGUI_ENABLE_FREETYPE
#include "user_interface/fonts/imgui_freetype.h"
 
 
namespace dnf_composer
{
    // Base template: assumes T does not have a constructor that takes Simulation*
    template<typename T, typename = void>
    struct has_simulation_constructor : std::false_type {};
 
    // Specialization for types that take a Simulation*
    template<typename T>
    struct has_simulation_constructor<T,
        std::void_t<decltype(T(std::declval<std::shared_ptr<Simulation>>()))>> : std::true_type {};
 
    // Base template: assumes T does not have a constructor that takes Visualization*
    template<typename T, typename = void>
    struct has_visualization_constructor : std::false_type {};
 
    // Specialization for types that take a Visualization*
    template<typename T>
    struct has_visualization_constructor<T,
        std::void_t<decltype(T(std::declval<std::shared_ptr<Visualization>>()))>> : std::true_type {};
 
    class Application
    {
    private:
        std::shared_ptr<Simulation> simulation;
        std::shared_ptr<Visualization> visualization;
        std::shared_ptr<imgui_kit::UserInterface> gui;
        bool guiActive;
        static float uiScalePct; 
 
    public:
        static float  getUiScalePct()          { return uiScalePct; }
        static void   setUiScalePct(float pct) { uiScalePct = pct; }
 
        explicit Application(const std::shared_ptr<Simulation>& simulation = nullptr,
            const std::shared_ptr<Visualization>& visualization = nullptr);
 
        void init() const;
 
        void step() const;
 
        void close() const;
 
        static void registerSettingsHandler();
 
        template<typename WindowType, typename... Args>
        void addWindow(Args&&... args) const requires (!has_simulation_constructor<WindowType>::value &&
            !has_visualization_constructor<WindowType>::value) {
            gui->addWindow<WindowType>(std::forward<Args>(args)...);
        }
 
        template<typename WindowType, typename... Args>
        void addWindow(Args&&... args) const requires has_simulation_constructor<WindowType>::value {
            gui->addWindow<WindowType>(simulation, std::forward<Args>(args)...);
        }
 
        template<typename WindowType, typename... Args>
        void addWindow(Args&&... args) const requires (!has_simulation_constructor<WindowType>::value&&
            has_visualization_constructor<WindowType>::value) {
            gui->addWindow<WindowType>(visualization, std::forward<Args>(args)...);
        }
 
        void toggleGUI();
 
        [[nodiscard]] bool hasGUIBeenClosed() const;
 
        [[nodiscard]] bool isGUIActive() const;
 
        ~Application() = default;
    private:
        void setGUIParameters();
        static void enableKeyboardShortcuts();
        static void appendFonts();
        static void defineImGuiStyle();
    };
 
    // Text fonts — 3 sizes per weight
    inline ImFont* g_LightMediumFont;   
    inline ImFont* g_LightSmallFont;    
    inline ImFont* g_LightLargeFont;    
 
    inline ImFont* g_MediumSmallFont;   
    inline ImFont* g_MediumMediumFont;  
    inline ImFont* g_MediumLargeFont;   
 
    inline ImFont* g_BoldSmallFont;     
    inline ImFont* g_BoldMediumFont;    
    inline ImFont* g_BoldLargeFont;     
 
    inline ImFont* g_BlackSmallFont;    
    inline ImFont* g_BlackMediumFont;   
    inline ImFont* g_BlackLargeFont;    
 
    inline ImFont* g_MonoSmallFont;     
    inline ImFont* g_MonoMediumFont;    
    inline ImFont* g_MonoLargeFont;     
 
    inline constexpr size_t g_FontCount = 15; 
    inline ImFont* g_SmallIconsFont;    
    inline ImFont* g_MediumIconsFont;   
    inline ImFont* g_LargeIconsFont;    
}