chore: structured src/gui, run clang-format

src/gui/platform/file_browser.hpp

@@ -0,0 +1,21 @@
+#ifndef CLRSYNC_GUI_FILE_BROWSER_HPP
+#define CLRSYNC_GUI_FILE_BROWSER_HPP
+
+#include <string>
+#include <vector>
+
+namespace file_dialogs
+{
+std::string open_file_dialog(const std::string &title = "Open File",
+                             const std::string &initial_path = "",
+                             const std::vector<std::string> &filters = {});
+
+std::string save_file_dialog(const std::string &title = "Save File",
+                             const std::string &initial_path = "",
+                             const std::vector<std::string> &filters = {});
+
+std::string select_folder_dialog(const std::string &title = "Select Folder",
+                                 const std::string &initial_path = "");
+} // namespace file_dialogs
+
+#endif // CLRSYNC_GUI_FILE_BROWSER_HPP

src/gui/platform/font_loader.hpp

@@ -0,0 +1,31 @@
+#ifndef CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
+#define CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
+
+#include <imgui.h>
+#include <string>
+#include <vector>
+
+class font_loader
+{
+  public:
+    font_loader() = default;
+
+    ImFont *load_font(const char *font_name, float size_px);
+    void push_default_font();
+    void pop_font();
+
+    std::vector<std::string> get_system_fonts();
+
+  private:
+    std::string find_font_path(const char *font_name);
+
+#if defined(_WIN32)
+    static std::string find_font_windows(const char *font_name);
+#elif defined(__APPLE__)
+    std::vector<unsigned char> load_font_macos(const char *font_name);
+#else
+    std::string find_font_linux(const char *font_name);
+#endif
+};
+
+#endif // CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP

src/gui/platform/linux/file_browser_linux.cpp

@@ -0,0 +1,132 @@
+#ifdef __linux__
+
+#include "gui/platform/file_browser.hpp"
+#include <gtk/gtk.h>
+
+namespace file_dialogs
+{
+
+std::string open_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    if (!gtk_init_check(nullptr, nullptr))
+    {
+        return "";
+    }
+
+    GtkFileChooserNative *native = gtk_file_chooser_native_new(
+        title.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_OPEN, "_Open", "_Cancel");
+
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+
+    if (!initial_path.empty())
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::exists(p))
+        {
+            if (std::filesystem::is_directory(p))
+            {
+                gtk_file_chooser_set_current_folder(chooser, initial_path.c_str());
+            }
+            else
+            {
+                gtk_file_chooser_set_current_folder(chooser, p.parent_path().c_str());
+                gtk_file_chooser_set_current_name(chooser, p.filename().c_str());
+            }
+        }
+    }
+
+    std::string result;
+    if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(native)) == GTK_RESPONSE_ACCEPT)
+    {
+        char *filename = gtk_file_chooser_get_filename(chooser);
+        if (filename)
+        {
+            result = filename;
+            g_free(filename);
+        }
+    }
+
+    g_object_unref(native);
+    while (gtk_events_pending())
+        gtk_main_iteration();
+    return result;
+}
+
+std::string save_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    if (!gtk_init_check(nullptr, nullptr))
+    {
+        return "";
+    }
+
+    GtkFileChooserNative *native = gtk_file_chooser_native_new(
+        title.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_SAVE, "_Save", "_Cancel");
+
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+    gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
+
+    if (!initial_path.empty())
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::exists(p.parent_path()))
+        {
+            gtk_file_chooser_set_current_folder(chooser, p.parent_path().c_str());
+            gtk_file_chooser_set_current_name(chooser, p.filename().c_str());
+        }
+    }
+
+    std::string result;
+    if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(native)) == GTK_RESPONSE_ACCEPT)
+    {
+        char *filename = gtk_file_chooser_get_filename(chooser);
+        if (filename)
+        {
+            result = filename;
+            g_free(filename);
+        }
+    }
+
+    g_object_unref(native);
+    while (gtk_events_pending())
+        gtk_main_iteration();
+    return result;
+}
+
+std::string select_folder_dialog(const std::string &title, const std::string &initial_path)
+{
+    if (!gtk_init_check(nullptr, nullptr))
+    {
+        return "";
+    }
+
+    GtkFileChooserNative *native = gtk_file_chooser_native_new(
+        title.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "_Select", "_Cancel");
+
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+
+    if (!initial_path.empty() && std::filesystem::exists(initial_path))
+    {
+        gtk_file_chooser_set_current_folder(chooser, initial_path.c_str());
+    }
+
+    std::string result;
+    if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(native)) == GTK_RESPONSE_ACCEPT)
+    {
+        char *filename = gtk_file_chooser_get_filename(chooser);
+        if (filename)
+        {
+            result = filename;
+            g_free(filename);
+        }
+    }
+
+    g_object_unref(native);
+    while (gtk_events_pending())
+        gtk_main_iteration();
+    return result;
+}
+
+} // namespace file_dialogs
+#endif

src/gui/platform/linux/font_loader_linux.cpp

@@ -0,0 +1,95 @@
+#ifdef __linux__
+
+#include "core/config/config.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "imgui_internal.h"
+#include <algorithm>
+#include <fontconfig/fontconfig.h>
+#include <imgui.h>
+
+std::string font_loader::find_font_linux(const char *font_name)
+{
+    FcInit();
+
+    FcPattern *pattern = FcNameParse(reinterpret_cast<const FcChar8 *>(font_name));
+    if (!pattern)
+        return {};
+
+    FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
+    FcDefaultSubstitute(pattern);
+
+    FcResult result;
+    FcPattern *match = FcFontMatch(nullptr, pattern, &result);
+
+    std::string out;
+
+    if (match)
+    {
+        FcChar8 *file = nullptr;
+        if (FcPatternGetString(match, FC_FILE, 0, &file) == FcResultMatch)
+            out = reinterpret_cast<const char *>(file);
+
+        FcPatternDestroy(match);
+    }
+
+    FcPatternDestroy(pattern);
+    return out;
+}
+
+std::string font_loader::find_font_path(const char *font_name)
+{
+    return find_font_linux(font_name);
+}
+
+ImFont *font_loader::load_font(const char *font_name, float size_px)
+{
+    std::string path = find_font_path(font_name);
+    if (path.empty())
+        return nullptr;
+
+    float scale = ImGui::GetIO().DisplayFramebufferScale.y;
+    return ImGui::GetIO().Fonts->AddFontFromFileTTF(path.c_str(), size_px * scale);
+}
+
+void font_loader::push_default_font()
+{
+    ImGui::PushFont(ImGui::GetDefaultFont(), clrsync::core::config::instance().font_size());
+}
+
+void font_loader::pop_font()
+{
+    ImGui::PopFont();
+}
+
+std::vector<std::string> font_loader::get_system_fonts()
+{
+    std::vector<std::string> fonts;
+
+    FcInit();
+    FcPattern *pattern = FcPatternCreate();
+    FcObjectSet *os = FcObjectSetBuild(FC_FAMILY, nullptr);
+    FcFontSet *fs = FcFontList(nullptr, pattern, os);
+
+    if (fs)
+    {
+        for (int i = 0; i < fs->nfont; i++)
+        {
+            FcChar8 *family = nullptr;
+            if (FcPatternGetString(fs->fonts[i], FC_FAMILY, 0, &family) == FcResultMatch)
+            {
+                std::string font_name = reinterpret_cast<const char *>(family);
+                if (std::find(fonts.begin(), fonts.end(), font_name) == fonts.end())
+                    fonts.push_back(font_name);
+            }
+        }
+        FcFontSetDestroy(fs);
+    }
+
+    FcObjectSetDestroy(os);
+    FcPatternDestroy(pattern);
+
+    std::sort(fonts.begin(), fonts.end());
+    return fonts;
+}
+
+#endif

src/gui/platform/macos/file_browser_macos.mm

@@ -0,0 +1,78 @@
+#ifdef __APPLE__
+#include "gui/platform/file_browser.hpp"
+#include <filesystem>
+#include <Cocoa/Cocoa.h>
+
+namespace file_dialogs {
+
+std::string open_file_dialog(const std::string& title, 
+                             const std::string& initial_path,
+                             const std::vector<std::string>& filters) {
+    @autoreleasepool {
+        NSOpenPanel* panel = [NSOpenPanel openPanel];
+        [panel setTitle:[NSString stringWithUTF8String:title.c_str()]];
+        [panel setCanChooseFiles:YES];
+        [panel setCanChooseDirectories:NO];
+        [panel setAllowsMultipleSelection:NO];
+        
+        if (!initial_path.empty()) {
+            NSURL* url = [NSURL fileURLWithPath:[NSString stringWithUTF8String:initial_path.c_str()]];
+            [panel setDirectoryURL:url];
+        }
+        
+        if ([panel runModal] == NSModalResponseOK) {
+            NSURL* url = [[panel URLs] objectAtIndex:0];
+            return std::string([[url path] UTF8String]);
+        }
+    }
+    return "";
+}
+
+std::string save_file_dialog(const std::string& title,
+                             const std::string& initial_path,
+                             const std::vector<std::string>& filters) {
+    @autoreleasepool {
+        NSSavePanel* panel = [NSSavePanel savePanel];
+        [panel setTitle:[NSString stringWithUTF8String:title.c_str()]];
+        
+        if (!initial_path.empty()) {
+            std::filesystem::path p(initial_path);
+            if (std::filesystem::exists(p.parent_path())) {
+                NSURL* url = [NSURL fileURLWithPath:[NSString stringWithUTF8String:p.parent_path().c_str()]];
+                [panel setDirectoryURL:url];
+                [panel setNameFieldStringValue:[NSString stringWithUTF8String:p.filename().c_str()]];
+            }
+        }
+        
+        if ([panel runModal] == NSModalResponseOK) {
+            NSURL* url = [panel URL];
+            return std::string([[url path] UTF8String]);
+        }
+    }
+    return "";
+}
+
+std::string select_folder_dialog(const std::string& title,
+                                 const std::string& initial_path) {
+    @autoreleasepool {
+        NSOpenPanel* panel = [NSOpenPanel openPanel];
+        [panel setTitle:[NSString stringWithUTF8String:title.c_str()]];
+        [panel setCanChooseFiles:NO];
+        [panel setCanChooseDirectories:YES];
+        [panel setAllowsMultipleSelection:NO];
+        
+        if (!initial_path.empty()) {
+            NSURL* url = [NSURL fileURLWithPath:[NSString stringWithUTF8String:initial_path.c_str()]];
+            [panel setDirectoryURL:url];
+        }
+        
+        if ([panel runModal] == NSModalResponseOK) {
+            NSURL* url = [[panel URLs] objectAtIndex:0];
+            return std::string([[url path] UTF8String]);
+        }
+    }
+    return "";
+}
+
+}
+#endif

src/gui/platform/macos/font_loader_macos.cpp

@@ -0,0 +1,115 @@
+#ifdef __APPLE__
+
+#include "core/config/config.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "imgui_internal.h"
+#include <CoreText/CoreText.h>
+#include <algorithm>
+#include <imgui.h>
+
+std::vector<unsigned char> font_loader::load_font_macos(const char *font_name)
+{
+    std::vector<unsigned char> out;
+
+    CFStringRef cf_name = CFStringCreateWithCString(nullptr, font_name, kCFStringEncodingUTF8);
+    if (!cf_name)
+        return out;
+
+    CTFontDescriptorRef desc = CTFontDescriptorCreateWithNameAndSize(cf_name, 12);
+    CFRelease(cf_name);
+
+    if (!desc)
+        return out;
+
+    CFURLRef url = (CFURLRef)CTFontDescriptorCopyAttribute(desc, kCTFontURLAttribute);
+    CFRelease(desc);
+
+    if (!url)
+        return out;
+
+    CFDataRef data = nullptr;
+    Boolean success = CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, url, &data,
+                                                               nullptr, nullptr, nullptr);
+    CFRelease(url);
+
+    if (success && data)
+    {
+        CFIndex size = CFDataGetLength(data);
+        if (size > 100)
+        {
+            out.resize(size);
+            CFDataGetBytes(data, CFRangeMake(0, size), out.data());
+        }
+        CFRelease(data);
+    }
+
+    return out;
+}
+
+std::string font_loader::find_font_path(const char *font_name)
+{
+    (void)font_name;
+    return {};
+}
+
+ImFont *font_loader::load_font(const char *font_name, float size_px)
+{
+    std::vector<unsigned char> buf = load_font_macos(font_name);
+    if (buf.empty())
+        return nullptr;
+
+    return ImGui::GetIO().Fonts->AddFontFromMemoryTTF(buf.data(), static_cast<int>(buf.size()),
+                                                      size_px);
+}
+
+void font_loader::push_default_font()
+{
+    ImGui::PushFont(ImGui::GetDefaultFont(), clrsync::core::config::instance().font_size());
+}
+
+void font_loader::pop_font()
+{
+    ImGui::PopFont();
+}
+
+std::vector<std::string> font_loader::get_system_fonts()
+{
+    std::vector<std::string> fonts;
+
+    CTFontCollectionRef collection = CTFontCollectionCreateFromAvailableFonts(nullptr);
+    if (collection)
+    {
+        CFArrayRef fontDescriptors = CTFontCollectionCreateMatchingFontDescriptors(collection);
+        CFRelease(collection);
+
+        if (fontDescriptors)
+        {
+            CFIndex count = CFArrayGetCount(fontDescriptors);
+            for (CFIndex i = 0; i < count; i++)
+            {
+                CTFontDescriptorRef descriptor =
+                    (CTFontDescriptorRef)CFArrayGetValueAtIndex(fontDescriptors, i);
+                CFStringRef fontName = (CFStringRef)CTFontDescriptorCopyAttribute(
+                    descriptor, kCTFontDisplayNameAttribute);
+
+                if (fontName)
+                {
+                    char buffer[256];
+                    if (CFStringGetCString(fontName, buffer, sizeof(buffer), kCFStringEncodingUTF8))
+                    {
+                        std::string font_name = buffer;
+                        if (std::find(fonts.begin(), fonts.end(), font_name) == fonts.end())
+                            fonts.push_back(font_name);
+                    }
+                    CFRelease(fontName);
+                }
+            }
+            CFRelease(fontDescriptors);
+        }
+    }
+
+    std::sort(fonts.begin(), fonts.end());
+    return fonts;
+}
+
+#endif

src/gui/platform/windows/file_browser_windows.cpp

@@ -0,0 +1,160 @@
+#ifdef _WIN32
+
+#include "gui/platform/file_browser.hpp"
+#include <filesystem>
+
+#include <commdlg.h>
+#include <shlobj.h>
+#include <shlwapi.h>
+#include <windows.h>
+
+namespace file_dialogs
+{
+
+std::string open_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    OPENFILENAMEA ofn;
+    char file[MAX_PATH] = "";
+
+    std::string filter_str = "All Files (*.*)\0*.*\0";
+
+    ZeroMemory(&ofn, sizeof(ofn));
+    ofn.lStructSize = sizeof(ofn);
+    ofn.hwndOwner = GetActiveWindow();
+    ofn.lpstrFile = file;
+    ofn.nMaxFile = sizeof(file);
+    ofn.lpstrFilter = filter_str.c_str();
+    ofn.nFilterIndex = 1;
+    ofn.lpstrTitle = title.c_str();
+    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
+
+    if (!initial_path.empty() && std::filesystem::exists(initial_path))
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::is_directory(p))
+        {
+            ofn.lpstrInitialDir = initial_path.c_str();
+        }
+        else
+        {
+            std::string dir = p.parent_path().string();
+            std::string name = p.filename().string();
+            ofn.lpstrInitialDir = dir.c_str();
+            strncpy(file, name.c_str(), sizeof(file) - 1);
+        }
+    }
+
+    if (GetOpenFileNameA(&ofn))
+    {
+        return std::string(file);
+    }
+    return "";
+}
+
+std::string save_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    OPENFILENAMEA ofn;
+    char file[MAX_PATH] = "";
+
+    std::string filter_str = "All Files\0*.*\0\0";
+
+    ZeroMemory(&ofn, sizeof(ofn));
+    ofn.lStructSize = sizeof(ofn);
+    ofn.hwndOwner = GetActiveWindow();
+    ofn.lpstrFile = file;
+    ofn.nMaxFile = sizeof(file);
+    ofn.lpstrFilter = filter_str.c_str();
+    ofn.nFilterIndex = 1;
+    ofn.lpstrTitle = title.c_str();
+    ofn.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_NOCHANGEDIR;
+
+    if (!initial_path.empty())
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::exists(p) && std::filesystem::is_directory(p))
+        {
+            ofn.lpstrInitialDir = initial_path.c_str();
+        }
+        else
+        {
+            std::string dir = p.parent_path().string();
+            std::string name = p.filename().string();
+            if (std::filesystem::exists(dir))
+            {
+                ofn.lpstrInitialDir = dir.c_str();
+                strncpy(file, name.c_str(), sizeof(file) - 1);
+            }
+        }
+    }
+
+    if (GetSaveFileNameA(&ofn))
+    {
+        return std::string(file);
+    }
+    return "";
+}
+
+std::string select_folder_dialog(const std::string &title, const std::string &initial_path)
+{
+    IFileOpenDialog *pFileOpen;
+
+    HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_ALL, IID_IFileOpenDialog,
+                                  reinterpret_cast<void **>(&pFileOpen));
+
+    if (SUCCEEDED(hr))
+    {
+        DWORD dwFlags;
+        if (SUCCEEDED(pFileOpen->GetOptions(&dwFlags)))
+        {
+            pFileOpen->SetOptions(dwFlags | FOS_PICKFOLDERS);
+        }
+
+        std::wstring wtitle(title.begin(), title.end());
+        pFileOpen->SetTitle(wtitle.c_str());
+
+        if (!initial_path.empty() && std::filesystem::exists(initial_path))
+        {
+            IShellItem *psi = NULL;
+            std::wstring winitial(initial_path.begin(), initial_path.end());
+            hr = SHCreateItemFromParsingName(winitial.c_str(), NULL, IID_IShellItem, (void **)&psi);
+            if (SUCCEEDED(hr))
+            {
+                pFileOpen->SetFolder(psi);
+                psi->Release();
+            }
+        }
+
+        hr = pFileOpen->Show(GetActiveWindow());
+
+        if (SUCCEEDED(hr))
+        {
+            IShellItem *pItem;
+            hr = pFileOpen->GetResult(&pItem);
+            if (SUCCEEDED(hr))
+            {
+                PWSTR pszFilePath;
+                hr = pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);
+
+                if (SUCCEEDED(hr))
+                {
+                    std::wstring wpath(pszFilePath);
+                    std::string result(wpath.begin(), wpath.end());
+                    CoTaskMemFree(pszFilePath);
+                    pItem->Release();
+                    pFileOpen->Release();
+                    return result;
+                }
+                pItem->Release();
+            }
+        }
+        pFileOpen->Release();
+    }
+
+    return "";
+}
+
+} // namespace file_dialogs
+
+#endif

src/gui/platform/windows/font_loader_windows.cpp

@@ -0,0 +1,168 @@
+#include "core/config/config.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "imgui_internal.h"
+#include <algorithm>
+#include <imgui.h>
+#include <windows.h>
+#include <winreg.h>
+
+static std::string search_registry_for_font(HKEY root_key, const char *subkey,
+                                            const std::string &font_name_lower,
+                                            const char *default_font_dir)
+{
+    HKEY hKey;
+    LONG result = RegOpenKeyExA(root_key, subkey, 0, KEY_READ, &hKey);
+
+    if (result != ERROR_SUCCESS)
+        return {};
+
+    char value_name[512];
+    BYTE value_data[512];
+    DWORD value_name_size, value_data_size, type;
+    DWORD index = 0;
+
+    std::string found_path;
+
+    while (true)
+    {
+        value_name_size = sizeof(value_name);
+        value_data_size = sizeof(value_data);
+
+        result = RegEnumValueA(hKey, index++, value_name, &value_name_size, nullptr, &type,
+                               value_data, &value_data_size);
+
+        if (result != ERROR_SUCCESS)
+            break;
+
+        if (type != REG_SZ)
+            continue;
+
+        std::string reg_font_name = value_name;
+        std::transform(reg_font_name.begin(), reg_font_name.end(), reg_font_name.begin(),
+                       ::tolower);
+
+        std::string reg_font_name_clean = reg_font_name;
+        size_t type_pos = reg_font_name_clean.find(" (");
+        if (type_pos != std::string::npos)
+            reg_font_name_clean = reg_font_name_clean.substr(0, type_pos);
+
+        if (reg_font_name_clean == font_name_lower)
+        {
+            std::string font_file = reinterpret_cast<char *>(value_data);
+
+            // If path is not absolute, prepend default font directory
+            if (font_file.find(":\\") == std::string::npos)
+            {
+                found_path = std::string(default_font_dir) + "\\" + font_file;
+            }
+            else
+            {
+                found_path = font_file;
+            }
+            break;
+        }
+    }
+
+    RegCloseKey(hKey);
+    return found_path;
+}
+
+std::string font_loader::find_font_windows(const char *font_name)
+{
+    std::string font_name_lower = font_name;
+    std::transform(font_name_lower.begin(), font_name_lower.end(), font_name_lower.begin(),
+                   ::tolower);
+
+    char windows_dir[MAX_PATH];
+    GetWindowsDirectoryA(windows_dir, MAX_PATH);
+    std::string system_fonts_dir = std::string(windows_dir) + "\\Fonts";
+
+    // First, try system-wide fonts (HKEY_LOCAL_MACHINE)
+    std::string path = search_registry_for_font(
+        HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
+        font_name_lower, system_fonts_dir.c_str());
+
+    if (!path.empty())
+        return path;
+
+    // If not found, try per-user fonts (HKEY_CURRENT_USER)
+    char local_appdata[MAX_PATH];
+    if (GetEnvironmentVariableA("LOCALAPPDATA", local_appdata, MAX_PATH) > 0)
+    {
+        std::string user_fonts_dir = std::string(local_appdata) + "\\Microsoft\\Windows\\Fonts";
+
+        path = search_registry_for_font(HKEY_CURRENT_USER,
+                                        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
+                                        font_name_lower, user_fonts_dir.c_str());
+    }
+
+    return path;
+}
+
+std::string font_loader::find_font_path(const char *font_name)
+{
+    return find_font_windows(font_name);
+}
+
+ImFont *font_loader::load_font(const char *font_name, float size_px)
+{
+    std::string path = find_font_path(font_name);
+    if (path.empty())
+        return nullptr;
+
+    float scale = ImGui::GetIO().DisplayFramebufferScale.y;
+    return ImGui::GetIO().Fonts->AddFontFromFileTTF(path.c_str(), size_px * scale);
+}
+
+void font_loader::push_default_font()
+{
+    ImGui::PushFont(ImGui::GetDefaultFont(), clrsync::core::config::instance().font_size());
+}
+
+void font_loader::pop_font()
+{
+    ImGui::PopFont();
+}
+
+std::vector<std::string> font_loader::get_system_fonts()
+{
+    std::vector<std::string> fonts;
+
+    auto enumerate_registry_fonts = [&fonts](HKEY root_key, const char *subkey) {
+        HKEY hKey;
+        if (RegOpenKeyExA(root_key, subkey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
+            return;
+
+        char value_name[512];
+        DWORD value_name_size;
+        DWORD index = 0;
+
+        while (true)
+        {
+            value_name_size = sizeof(value_name);
+            LONG result = RegEnumValueA(hKey, index++, value_name, &value_name_size, nullptr,
+                                        nullptr, nullptr, nullptr);
+
+            if (result != ERROR_SUCCESS)
+                break;
+
+            std::string font_name = value_name;
+            size_t pos = font_name.find(" (");
+            if (pos != std::string::npos)
+                font_name = font_name.substr(0, pos);
+
+            if (std::find(fonts.begin(), fonts.end(), font_name) == fonts.end())
+                fonts.push_back(font_name);
+        }
+
+        RegCloseKey(hKey);
+    };
+
+    enumerate_registry_fonts(HKEY_LOCAL_MACHINE,
+                             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts");
+    enumerate_registry_fonts(HKEY_CURRENT_USER,
+                             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts");
+
+    std::sort(fonts.begin(), fonts.end());
+    return fonts;
+}