ImUtil.h

Go to the documentation of this file.

 
#pragma once
 
#include "Core/App.h"
#include <algorithm>
#include <filesystem>
#include <fstream>
 
#include "Anim/Anim.h"
#include "imgui.h"
#include <string_view>
#include <unordered_map>
 
namespace FuncDoodle {
    inline std::unordered_map<ImGuiID, double>& GetAnimTimers() {
        static std::unordered_map<ImGuiID, double> timers;
        return timers;
    }
 
    inline void ClearAnimTimers() {
        GetAnimTimers().clear();
    }

    inline bool ImBegin(const char* name, bool* p_open, ImGuiWindowFlags flags,
        Application* app) {
 
        if (!app->GetCurProj())
            return ImGui::Begin(name, p_open, flags);
 
        ImGuiID id = ImGui::GetID(name);
        double& t = GetAnimTimers()[id];
 
        double dt = app->GetDt();
 
        bool isOpen = (p_open == nullptr) ? true : *p_open;
        double alpha =
            std::max(Anim::Animate(isOpen, 2.0, t, dt, Anim::OutCubic), 0.3);
 
        ImGui::PushStyleVar(ImGuiStyleVar_Alpha, (float)alpha);
        bool result = ImGui::Begin(name, p_open, flags);
 
        return result;
    }

    inline void ImEnd() {
        ImGui::End();
        ImGui::PopStyleVar();
    }
 
}  // namespace FuncDoodle

namespace FuncDoodle::ImUtil {
    // NOLINTBEGIN
    inline constexpr char s_DefaultLayout[] = {
#embed "../Conf/imgui.ini"
        , 0};
    // NOLINTEND

    inline void SetupDefaultLayout() {
        ImGuiIO& io = ImGui::GetIO();
        const char* userIniPath = "imgui.ini";
 
        io.IniFilename = userIniPath;
 
        if (!std::filesystem::exists(userIniPath)) {
            ImGui::LoadIniSettingsFromMemory(s_DefaultLayout);
 
            std::ofstream outFile(userIniPath);
            if (outFile) {
                outFile << s_DefaultLayout;
                outFile.close();
            }
        }
    }

    enum class ButtonRowResult { None, Primary, Secondary, Tertiary };

    inline float ButtonWidth(const char* label) {
        ImVec2 size = ImGui::CalcTextSize(label);
        return size.x + (ImGui::GetStyle().FramePadding.x * 2.0f);
    }

    inline void AlignButtonsRight(float totalWidth) {
        float avail = ImGui::GetContentRegionAvail().x;
        float startX =
            ImGui::GetCursorPosX() + std::max(0.0f, avail - totalWidth);
        ImGui::SetCursorPosX(startX);
    }

    inline bool EnterPressed() {
        return ImGui::IsKeyPressed(ImGuiKey_Enter, false) ||
               ImGui::IsKeyPressed(ImGuiKey_KeypadEnter, false);
    }

    inline bool EscPressed() {
        return ImGui::IsKeyPressed(ImGuiKey_Escape, false);
    }

    inline ButtonRowResult ConfirmButtons(const char* primary,
        const char* secondary, const char* tertiary = nullptr) {
        float spacing = ImGui::GetStyle().ItemSpacing.x;
        float primaryWidth = ButtonWidth(primary);
        float secondaryWidth = ButtonWidth(secondary);
        float tertiaryWidth = tertiary ? ButtonWidth(tertiary) : 0.0f;
        int count = tertiary ? 3 : 2;
        float totalWidth = primaryWidth + secondaryWidth + tertiaryWidth +
                           (spacing * (count - 1));
        AlignButtonsRight(totalWidth);
 
        ButtonRowResult result = ButtonRowResult::None;
        if (tertiary) {
            if (ImGui::Button(tertiary))
                result = ButtonRowResult::Tertiary;
            ImGui::SameLine();
        }
        if (ImGui::Button(secondary))
            result = ButtonRowResult::Secondary;
        ImGui::SameLine();
        if (ImGui::Button(primary))
            result = ButtonRowResult::Primary;
        return result;
    }

    inline ButtonRowResult OkCancelButtons() {
        return ConfirmButtons("OK", "Cancel");
    }

    inline ButtonRowResult YesNoButtons() {
        return ConfirmButtons("Yes", "No");
    }

    inline ButtonRowResult YesNoCancelButtons() {
        return ConfirmButtons("Yes", "No", "Cancel");
    }

    inline ButtonRowResult CloseOkButtons() {
        return ConfirmButtons("OK", "Close");
    }

    inline ButtonRowResult CreateCancelButtons() {
        return ConfirmButtons("Create", "Cancel");
    }

    inline ButtonRowResult ExportCloseButtons() {
        return ConfirmButtons("Export", "Close");
    }

    inline bool SingleButtonRow(const char* label) {
        AlignButtonsRight(ButtonWidth(label));
        return ImGui::Button(label);
    }

    inline bool OkButton() {
        return SingleButtonRow("OK");
    }

    inline bool CloseButton() {
        return SingleButtonRow("Close");
    }

    inline ImGuiKey GetAnyReleasedKey() {
        for (int i = ImGuiKey_NamedKey_BEGIN; i < ImGuiKey_NamedKey_END; i++) {
            auto key = (ImGuiKey)i;
            if (key == ImGuiKey_LeftCtrl || key == ImGuiKey_RightCtrl ||
                key == ImGuiKey_LeftShift || key == ImGuiKey_RightShift ||
                key == ImGuiKey_LeftAlt || key == ImGuiKey_RightAlt ||
                key == ImGuiKey_LeftSuper || key == ImGuiKey_RightSuper ||
                key == ImGuiKey_MouseLeft || key == ImGuiKey_MouseRight)
                continue;
            if (ImGui::IsKeyReleased(key))
                return key;
        }
        return ImGuiKey_None;
    }

    inline const char* GetUsername() {
        const char* username =
            std::getenv("USER");  // Common on Linux and macOS
        if (!username) {
            username = std::getenv("LOGNAME");  // Fallback for Linux and macOS
        }
        if (!username) {
            username = std::getenv("USERNAME");  // Common on Windows
        }
        if (!username) {
            username = "unknown";
        }
 
        return username;
    }
 
    template<typename T>
    concept IntEnum =
        std::is_enum_v<T> &&
        std::same_as<std::underlying_type_t<T>, int> &&
        !std::convertible_to<T, int>;
 
    template<IntEnum T, size_t N>
    inline bool Combo(const char* title, T* buf, std::array<std::string_view, N> names) {
        std::array<const char*, N> ptrs{};
        for (size_t i = 0; i < N; ++i)
            ptrs[i] = names[i].data();
 
        return ImGui::Combo(title, reinterpret_cast<int*>(buf), ptrs.data(), names.size());
    }
 
    struct ImVec2iHash {
        size_t operator()(const ImVec2i& v) const {
            return std::hash<int>()(v.x) ^ (std::hash<int>()(v.y) << 32);
        }
    };
    struct ImVec2iEqual {
        bool operator()(const ImVec2i& a, const ImVec2i& b) const {
            return a.x == b.x && a.y == b.y;
        }
    };
}  // namespace FuncDoodle::ImUtil