fix: typo in font_loader.windows

.github/workflows/publish-release.yml

@@ -49,6 +49,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y cmake build-essential git \
             libglfw3-dev libfreetype6-dev libfontconfig1-dev \
+            zlib1g-dev libharfbuzz-dev \
             libx11-dev libxrandr-dev libxi-dev libgtk-3-dev \
             mesa-common-dev libgl1-mesa-dev libglu1-mesa-dev \
             libxinerama-dev libxcursor-dev libxkbcommon-dev
@@ -83,6 +84,7 @@ jobs:
         run: |
           dnf install -y cmake gcc gcc-c++ make rpm-build git \
             glfw-devel freetype-devel fontconfig-devel \
+            zlib-devel harfbuzz-devel \
             libX11-devel libXrandr-devel libXi-devel \
             mesa-libGL-devel mesa-libGLU-devel \
             libXinerama-devel libXcursor-devel \

AUR/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: Daniel Dada <dan@binarygoose.dev>
 pkgname=clrsync
-pkgver=0.1.6
+pkgver=0.1.7
 pkgrel=1
 pkgdesc="Color scheme manager"
 arch=('x86_64')

AUR/PKGBUILD-git

@@ -10,6 +10,8 @@ depends=(
     glfw
     freetype2
     fontconfig
+    zlib
+    harfbuzz
     mesa
     libglvnd
     libxcursor

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.25)
-project(clrsync VERSION 0.1.6 LANGUAGES CXX)
+project(clrsync VERSION 0.1.7 LANGUAGES CXX)
 
 include(GNUInstallDirs)
 
@@ -57,8 +57,8 @@ endif()
 message(STATUS "clrsync version: ${SEMVER}")
 
 configure_file(
-    ${CMAKE_SOURCE_DIR}/src/core/version.hpp.in
+    ${CMAKE_SOURCE_DIR}/src/core/common/version.hpp.in
-    ${CMAKE_SOURCE_DIR}/src/core/version.hpp
+    ${CMAKE_SOURCE_DIR}/src/core/common/version.hpp
     @ONLY
 )
 

VERSION

@@ -1 +1 @@
-0.1.6
+0.1.7

cmake/Dependencies.cmake

@@ -7,6 +7,13 @@ if(WIN32)
         freetype
         URL https://download.savannah.gnu.org/releases/freetype/freetype-2.14.1.tar.gz
     )
+    
+    set(FT_DISABLE_ZLIB FALSE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_BZIP2 TRUE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_PNG TRUE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_HARFBUZZ FALSE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_BROTLI TRUE CACHE BOOL "" FORCE)
+    
     FetchContent_MakeAvailable(freetype)
 elseif(APPLE)
     option(USE_SYSTEM_GLFW ON)
@@ -15,10 +22,6 @@ elseif(APPLE)
     find_package(BZip2 REQUIRED)
     find_package(PNG REQUIRED)
     
-    
-    find_library(BROTLIDEC_LIBRARY NAMES brotlidec)
-    find_library(BROTLICOMMON_LIBRARY NAMES brotlicommon)
-    
     find_package(PkgConfig QUIET)
     if(PkgConfig_FOUND)
         pkg_check_modules(HARFBUZZ harfbuzz)
@@ -30,10 +33,6 @@ else()
     find_package(ZLIB REQUIRED)
     find_package(BZip2 REQUIRED)
     find_package(PNG REQUIRED)
-
-    find_library(BROTLIDEC_LIBRARY NAMES brotlidec)
-    find_library(BROTLICOMMON_LIBRARY NAMES brotlicommon)
-
     pkg_check_modules(HARFBUZZ harfbuzz)
     pkg_check_modules(WAYLAND_CLIENT wayland-client)
     pkg_check_modules(WAYLAND_EGL wayland-egl)
@@ -77,11 +76,6 @@ else()
 endif()
 
 set(FREETYPE_EXTRA_LIBS "")
-if(BROTLIDEC_LIBRARY AND BROTLICOMMON_LIBRARY)
-    list(APPEND FREETYPE_EXTRA_LIBS ${BROTLIDEC_LIBRARY} ${BROTLICOMMON_LIBRARY})
-    message(STATUS "Found Brotli libraries")
-endif()
-
 if(HARFBUZZ_FOUND)
     list(APPEND FREETYPE_EXTRA_LIBS ${HARFBUZZ_LIBRARIES})
     message(STATUS "Found HarfBuzz")

cmake/Packaging.cmake

@@ -27,7 +27,7 @@ set(CPACK_NSIS_CREATE_DESKTOP_LINKS "bin/clrsync_gui.exe;clrsync")
 
 # Debian
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Daniel Dada <dan@binarygoose.dev>")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.31), libglfw3, libfreetype6")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.31), libglfw3, libfreetype6, zlib1g, libharfbuzz0b")
 set(CPACK_DEBIAN_PACKAGE_SECTION "utils")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
@@ -36,6 +36,6 @@ set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
 set(CPACK_RPM_PACKAGE_LICENSE "MIT")
 set(CPACK_RPM_PACKAGE_GROUP "Applications/System")
 set(CPACK_RPM_PACKAGE_URL "https://github.com/obsqrbtz/clrsync")
-set(CPACK_RPM_PACKAGE_REQUIRES "freetype, glfw, fontconfig")
+set(CPACK_RPM_PACKAGE_REQUIRES "freetype, glfw, fontconfig, zlib, harfbuzz")
 
 include(CPack)

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1764950072,
+        "lastModified": 1765779637,
-        "narHash": "sha256-BmPWzogsG2GsXZtlT+MTcAWeDK5hkbGRZTeZNW42fwA=",
+        "narHash": "sha256-KJ2wa/BLSrTqDjbfyNx70ov/HdgNBCBBSQP3BIzKnv4=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f61125a668a320878494449750330ca58b78c557",
+        "rev": "1306659b587dc277866c7b69eb97e5f07864d8c4",
         "type": "github"
       },
       "original": {

src/cli/main.cpp

@@ -4,15 +4,15 @@
 
 #include <argparse/argparse.hpp>
 
-#include <core/config/config.hpp>
+#include "core/common/error.hpp"
-#include <core/error.hpp>
+#include "core/common/utils.hpp"
-#include <core/io/toml_file.hpp>
+#include "core/common/version.hpp"
-#include <core/palette/palette_file.hpp>
+#include "core/config/config.hpp"
-#include <core/palette/palette_manager.hpp>
+#include "core/io/toml_file.hpp"
-#include <core/theme/theme_renderer.hpp>
+#include "core/palette/palette_file.hpp"
-#include <core/theme/theme_template.hpp>
+#include "core/palette/palette_manager.hpp"
-#include <core/utils.hpp>
+#include "core/theme/theme_renderer.hpp"
-#include <core/version.hpp>
+#include "core/theme/theme_template.hpp"
 
 void handle_show_vars()
 {

src/core/CMakeLists.txt

@@ -2,8 +2,8 @@ set(CORE_SOURCES
     palette/color.cpp
     io/toml_file.cpp
     config/config.cpp
-    utils.cpp
+        common/utils.cpp
-    version.cpp
+        common/version.cpp
     theme/theme_template.cpp
 )
 

src/core/common/error.hpp

@@ -0,0 +1,266 @@
+#ifndef CLRSYNC_CORE_ERROR_HPP
+#define CLRSYNC_CORE_ERROR_HPP
+
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace clrsync::core
+{
+
+enum class error_code
+{
+    unknown,
+
+    file_not_found,
+    file_open_failed,
+    file_write_failed,
+    file_read_failed,
+    dir_create_failed,
+
+    parse_failed,
+    invalid_format,
+
+    config_missing,
+    config_invalid,
+
+    template_not_found,
+    template_load_failed,
+    template_apply_failed,
+
+    palette_not_found,
+    palette_load_failed,
+
+    init_failed,
+    invalid_arg,
+    resource_missing,
+};
+
+inline const char *error_code_string(error_code code)
+{
+    switch (code)
+    {
+    case error_code::unknown:
+        return "Unknown error";
+    case error_code::file_not_found:
+        return "File not found";
+    case error_code::file_open_failed:
+        return "Failed to open file";
+    case error_code::file_write_failed:
+        return "Failed to write file";
+    case error_code::file_read_failed:
+        return "Failed to read file";
+    case error_code::dir_create_failed:
+        return "Failed to create directory";
+    case error_code::parse_failed:
+        return "Parse failed";
+    case error_code::invalid_format:
+        return "Invalid format";
+    case error_code::config_missing:
+        return "Configuration missing";
+    case error_code::config_invalid:
+        return "Configuration invalid";
+    case error_code::template_not_found:
+        return "Template not found";
+    case error_code::template_load_failed:
+        return "Failed to load template";
+    case error_code::template_apply_failed:
+        return "Failed to apply template";
+    case error_code::palette_not_found:
+        return "Palette not found";
+    case error_code::palette_load_failed:
+        return "Failed to load palette";
+    case error_code::init_failed:
+        return "Initialization failed";
+    case error_code::invalid_arg:
+        return "Invalid argument";
+    case error_code::resource_missing:
+        return "Resource missing";
+    default:
+        return "Unknown error code";
+    }
+}
+
+struct Error
+{
+    error_code code;
+    std::string message;
+    std::string context;
+
+    Error(error_code c) : code(c), message(error_code_string(c))
+    {
+    }
+
+    Error(error_code c, std::string msg) : code(c), message(std::move(msg))
+    {
+    }
+
+    Error(error_code c, std::string msg, std::string ctx)
+        : code(c), message(std::move(msg)), context(std::move(ctx))
+    {
+    }
+
+    std::string description() const
+    {
+        if (context.empty())
+            return message;
+        return message + " [" + context + "]";
+    }
+};
+
+template <typename T> class [[nodiscard]] Result
+{
+  private:
+    std::variant<T, Error> m_data;
+
+  public:
+    Result(T value) : m_data(std::move(value))
+    {
+    }
+
+    Result(Error error) : m_data(std::move(error))
+    {
+    }
+
+    bool is_ok() const
+    {
+        return std::holds_alternative<T>(m_data);
+    }
+
+    bool is_error() const
+    {
+        return std::holds_alternative<Error>(m_data);
+    }
+
+    explicit operator bool() const
+    {
+        return is_ok();
+    }
+
+    T &value() &
+    {
+        return std::get<T>(m_data);
+    }
+    const T &value() const &
+    {
+        return std::get<T>(m_data);
+    }
+    T &&value() &&
+    {
+        return std::get<T>(std::move(m_data));
+    }
+
+    const Error &error() const
+    {
+        return std::get<Error>(m_data);
+    }
+
+    T value_or(T default_value) const
+    {
+        return is_ok() ? std::get<T>(m_data) : std::move(default_value);
+    }
+
+    std::optional<T> ok() const
+    {
+        if (is_ok())
+            return std::get<T>(m_data);
+        return std::nullopt;
+    }
+
+    std::optional<Error> err() const
+    {
+        if (is_error())
+            return std::get<Error>(m_data);
+        return std::nullopt;
+    }
+
+    template <typename F> auto map(F &&func) -> Result<decltype(func(std::declval<T>()))>
+    {
+        using U = decltype(func(std::declval<T>()));
+        if (is_ok())
+            return Result<U>(func(std::get<T>(m_data)));
+        return Result<U>(std::get<Error>(m_data));
+    }
+
+    template <typename F> auto and_then(F &&func) -> decltype(func(std::declval<T>()))
+    {
+        if (is_ok())
+            return func(std::get<T>(m_data));
+        using ResultType = decltype(func(std::declval<T>()));
+        return ResultType(std::get<Error>(m_data));
+    }
+};
+
+template <> class [[nodiscard]] Result<void>
+{
+  private:
+    std::optional<Error> m_error;
+
+  public:
+    Result() : m_error(std::nullopt)
+    {
+    }
+
+    Result(Error error) : m_error(std::move(error))
+    {
+    }
+
+    bool is_ok() const
+    {
+        return !m_error.has_value();
+    }
+
+    bool is_error() const
+    {
+        return m_error.has_value();
+    }
+
+    explicit operator bool() const
+    {
+        return is_ok();
+    }
+
+    const Error &error() const
+    {
+        return *m_error;
+    }
+
+    std::optional<Error> err() const
+    {
+        return m_error;
+    }
+};
+
+template <typename T> Result<T> Ok(T value)
+{
+    return Result<T>(std::move(value));
+}
+
+inline Result<void> Ok()
+{
+    return Result<void>();
+}
+
+template <typename T> Result<T> Err(Error error)
+{
+    return Result<T>(std::move(error));
+}
+
+template <typename T> Result<T> Err(error_code code)
+{
+    return Result<T>(Error(code));
+}
+
+template <typename T> Result<T> Err(error_code code, std::string message)
+{
+    return Result<T>(Error(code, std::move(message)));
+}
+
+template <typename T> Result<T> Err(error_code code, std::string message, std::string context)
+{
+    return Result<T>(Error(code, std::move(message), std::move(context)));
+}
+
+} // namespace clrsync::core
+
+#endif // CLRSYNC_CORE_ERROR_HPP

src/core/common/utils.cpp

@@ -1,6 +1,6 @@
 #include "utils.hpp"
-#include <iostream>
 #include <filesystem>
+#include <iostream>
 
 namespace clrsync::core
 {
@@ -14,7 +14,7 @@ void print_color_keys()
 
 std::string get_default_config_path()
 {
-    const char* env_path = std::getenv("CLRSYNC_CONFIG_PATH");
+    const char *env_path = std::getenv("CLRSYNC_CONFIG_PATH");
     if (env_path && env_path[0] != '\0')
         return normalize_path(env_path).string();
 

src/core/common/utils.hpp

@@ -1,10 +1,10 @@
 #ifndef CLRSYNC_CORE_UTILS_HPP
 #define CLRSYNC_CORE_UTILS_HPP
 
-#include <string>
 #include <filesystem>
+#include <string>
 
-#include <core/palette/color_keys.hpp>
+#include "core/palette/color_keys.hpp"
 
 namespace clrsync::core
 {

src/core/common/version.cpp

@@ -1,4 +1,4 @@
-#include "version.hpp"
+#include "core/common/version.hpp"
 
 namespace clrsync::core
 {

src/core/common/version.hpp

@@ -6,7 +6,7 @@
 namespace clrsync::core
 {
 
-const std::string GIT_SEMVER = "0.1.6+git.g1a1747a";
+const std::string GIT_SEMVER = "0.1.6+git.gdff3e91";
 
 const std::string version_string();
 } // namespace clrsync::core

src/core/config/config.cpp

@@ -1,8 +1,9 @@
 #include "config.hpp"
-#include "core/utils.hpp"
+#include "core/common/error.hpp"
-#include "core/error.hpp"
+#include "core/common/utils.hpp"
+#include "core/io/toml_file.hpp"
 
-#include <core/palette/color.hpp>
+#include "core/palette/color.hpp"
 #include <filesystem>
 #include <fstream>
 
@@ -28,7 +29,39 @@ Result<void> config::initialize(std::unique_ptr<clrsync::core::io::file> file)
 
     auto parse_result = m_file->parse();
     if (!parse_result)
-        return Err<void>(error_code::config_invalid, parse_result.error().message, parse_result.error().context);
+        return Err<void>(error_code::config_invalid, parse_result.error().message,
+                         parse_result.error().context);
+
+    std::filesystem::path config_path = get_user_config_dir() / "config.toml";
+    std::filesystem::path temp_config_path = get_user_config_dir() / "config-temp.toml";
+    
+    if (std::filesystem::exists(config_path))
+    {
+        std::error_code ec;
+        auto perms = std::filesystem::status(config_path, ec).permissions();
+        
+        if (ec || (perms & std::filesystem::perms::owner_write) == std::filesystem::perms::none)
+        {
+            m_temp_config_path = temp_config_path.string();
+            
+            if (std::filesystem::exists(temp_config_path))
+            {
+                try
+                {
+                    auto temp_conf = std::make_unique<clrsync::core::io::toml_file>(temp_config_path.string());
+                    auto temp_parse = temp_conf->parse();
+                    if (temp_parse)
+                    {
+                        m_temp_file = std::move(temp_conf);
+                    }
+                }
+                catch (const std::exception &e)
+                {
+                    std::cerr << "Warning: Failed to load temp config: " << e.what() << std::endl;
+                }
+            }
+        }
+    }
 
     return Ok();
 }
@@ -39,6 +72,30 @@ std::filesystem::path config::get_user_config_dir()
     return home / ".config" / "clrsync";
 }
 
+std::filesystem::path config::get_user_state_dir()
+{
+    std::filesystem::path home = normalize_path("~");
+    return home / ".local" / "state" / "clrsync";
+}
+
+std::filesystem::path config::get_writable_config_path()
+{
+    std::filesystem::path config_path = get_user_config_dir() / "config.toml";
+    
+    if (std::filesystem::exists(config_path))
+    {
+        std::error_code ec;
+        auto perms = std::filesystem::status(config_path, ec).permissions();
+        
+        if (ec || (perms & std::filesystem::perms::owner_write) == std::filesystem::perms::none)
+        {
+            return get_user_config_dir() / "config-temp.toml";
+        }
+    }
+    
+    return config_path;
+}
+
 std::filesystem::path config::get_data_dir()
 {
     if (std::filesystem::exists(CLRSYNC_DATADIR))
@@ -134,15 +191,50 @@ void config::copy_default_configs()
     }
 }
 
+Result<void> config::save_config_value(const std::string &section, const std::string &key, const value_type &value)
+{
+    if (!m_temp_config_path.empty())
+    {
+        if (!m_temp_file)
+        {
+            m_temp_file = std::make_unique<clrsync::core::io::toml_file>(m_temp_config_path);
+            m_temp_file->parse();
+        }
+        
+        m_temp_file->set_value(section, key, value);
+        return m_temp_file->save_file();
+    }
+    
+    m_file->set_value(section, key, value);
+    return m_file->save_file();
+}
+
 const std::string &config::palettes_path()
 {
     if (m_palettes_dir.empty() && m_file)
+    {
+        if (m_temp_file)
+        {
+            auto temp_value = m_temp_file->get_string_value("general", "palettes_path");
+            if (!temp_value.empty())
+            {
+                m_palettes_dir = temp_value;
+                return m_palettes_dir;
+            }
+        }
         m_palettes_dir = m_file->get_string_value("general", "palettes_path");
+    }
     return m_palettes_dir;
 }
 
 const std::string config::default_theme() const
 {
+    if (m_temp_file)
+    {
+        auto temp_value = m_temp_file->get_string_value("general", "default_theme");
+        if (!temp_value.empty())
+            return temp_value;
+    }
     if (m_file)
         return m_file->get_string_value("general", "default_theme");
     return {};
@@ -150,6 +242,12 @@ const std::string config::default_theme() const
 
 const std::string config::font() const
 {
+    if (m_temp_file)
+    {
+        auto temp_value = m_temp_file->get_string_value("general", "font");
+        if (!temp_value.empty())
+            return temp_value;
+    }
     if (m_file)
         return m_file->get_string_value("general", "font");
     return {};
@@ -157,6 +255,12 @@ const std::string config::font() const
 
 const uint32_t config::font_size() const
 {
+    if (m_temp_file)
+    {
+        auto temp_value = m_temp_file->get_uint_value("general", "font_size");
+        if (temp_value != 0)
+            return temp_value;
+    }
     if (m_file)
         return m_file->get_uint_value("general", "font_size");
     return 14;
@@ -167,8 +271,7 @@ Result<void> config::set_default_theme(const std::string &theme)
     if (!m_file)
         return Err<void>(error_code::config_missing, "Configuration not initialized");
 
-    m_file->set_value("general", "default_theme", theme);
+    return save_config_value("general", "default_theme", theme);
-    return m_file->save_file();
 }
 
 Result<void> config::set_palettes_path(const std::string &path)
@@ -176,8 +279,7 @@ Result<void> config::set_palettes_path(const std::string &path)
     if (!m_file)
         return Err<void>(error_code::config_missing, "Configuration not initialized");
 
-    m_file->set_value("general", "palettes_path", path);
+    return save_config_value("general", "palettes_path", path);
-    return m_file->save_file();
 }
 
 Result<void> config::set_font(const std::string &font)
@@ -185,16 +287,14 @@ Result<void> config::set_font(const std::string &font)
     if (!m_file)
         return Err<void>(error_code::config_missing, "Configuration not initialized");
 
-    m_file->set_value("general", "font", font);
+    return save_config_value("general", "font", font);
-    return m_file->save_file();
 }
 Result<void> config::set_font_size(int font_size)
 {
     if (!m_file)
         return Err<void>(error_code::config_missing, "Configuration not initialized");
 
-    m_file->set_value("general", "font_size", font_size);
+    return save_config_value("general", "font_size", static_cast<uint32_t>(font_size));
-    return m_file->save_file();
 }
 
 Result<void> config::update_template(const std::string &key,
@@ -204,11 +304,17 @@ Result<void> config::update_template(const std::string &key,
         return Err<void>(error_code::config_missing, "Configuration not initialized");
 
     m_themes[key] = theme_template;
-    m_file->set_value("templates." + key, "input_path", theme_template.template_path());
+    
-    m_file->set_value("templates." + key, "output_path", theme_template.output_path());
+    auto result1 = save_config_value("templates." + key, "input_path", theme_template.template_path());
-    m_file->set_value("templates." + key, "enabled", theme_template.enabled());
+    if (!result1) return result1;
-    m_file->set_value("templates." + key, "reload_cmd", theme_template.reload_command());
+    
-    return m_file->save_file();
+    auto result2 = save_config_value("templates." + key, "output_path", theme_template.output_path());
+    if (!result2) return result2;
+    
+    auto result3 = save_config_value("templates." + key, "enabled", theme_template.enabled());
+    if (!result3) return result3;
+    
+    return save_config_value("templates." + key, "reload_cmd", theme_template.reload_command());
 }
 
 Result<void> config::remove_template(const std::string &key)
@@ -223,17 +329,31 @@ Result<void> config::remove_template(const std::string &key)
     std::filesystem::path template_file = it->second.template_path();
     if (std::filesystem::exists(template_file))
     {
-        try {
+        try
+        {
             std::filesystem::remove(template_file);
-        } catch (const std::exception& e) {
+        }
-            return Err<void>(error_code::file_write_failed, "Failed to delete template file", e.what());
+        catch (const std::exception &e)
+        {
+            return Err<void>(error_code::file_write_failed, "Failed to delete template file",
+                             e.what());
         }
     }
 
     m_themes.erase(it);
 
-    m_file->remove_section("templates." + key);
+    if (!m_temp_config_path.empty())
+    {
+        if (!m_temp_file)
+        {
+            m_temp_file = std::make_unique<clrsync::core::io::toml_file>(m_temp_config_path);
+            m_temp_file->parse();
+        }
+        m_temp_file->remove_section("templates." + key);
+        return m_temp_file->save_file();
+    }
     
+    m_file->remove_section("templates." + key);
     return m_file->save_file();
 }
 
@@ -264,14 +384,16 @@ const std::unordered_map<std::string, clrsync::core::theme_template> config::tem
     return m_themes;
 }
 
-Result<const clrsync::core::theme_template*> config::template_by_name(const std::string &name) const
+Result<const clrsync::core::theme_template *> config::template_by_name(
+    const std::string &name) const
 {
     auto it = m_themes.find(name);
     if (it != m_themes.end())
     {
         return Ok(&it->second);
     }
-    return Err<const clrsync::core::theme_template*>(error_code::template_not_found, "Template not found", name);
+    return Err<const clrsync::core::theme_template *>(error_code::template_not_found,
+                                                      "Template not found", name);
 }
 
 } // namespace clrsync::core

src/core/config/config.hpp

@@ -1,9 +1,9 @@
 #ifndef CLRSYNC_CORE_CONFIG_HPP
 #define CLRSYNC_CORE_CONFIG_HPP
 
-#include <core/io/file.hpp>
+#include "core/common/error.hpp"
-#include <core/theme/theme_template.hpp>
+#include "core/io/file.hpp"
-#include <core/error.hpp>
+#include "core/theme/theme_template.hpp"
 #include <filesystem>
 #include <memory>
 #include <string>
@@ -22,9 +22,10 @@ class config
     const std::string &palettes_path();
     const std::string default_theme() const;
     const std::unordered_map<std::string, clrsync::core::theme_template> templates();
-    Result<const clrsync::core::theme_template*> template_by_name(const std::string &name) const;
+    Result<const clrsync::core::theme_template *> template_by_name(const std::string &name) const;
     std::filesystem::path get_user_config_dir();
-
+    std::filesystem::path get_user_state_dir();
+    std::filesystem::path get_writable_config_path();
 
     Result<void> set_default_theme(const std::string &theme);
     Result<void> set_palettes_path(const std::string &path);
@@ -43,9 +44,12 @@ class config
 
     std::string m_palettes_dir{};
     std::unique_ptr<io::file> m_file;
+    std::unique_ptr<io::file> m_temp_file; 
+    std::string m_temp_config_path;
     std::unordered_map<std::string, theme_template> m_themes{};
-    static void copy_file(const std::filesystem::path& src, const std::filesystem::path& dst);
+    Result<void> save_config_value(const std::string &section, const std::string &key, const value_type &value);
-    static void copy_dir(const std::filesystem::path& src, const std::filesystem::path& dst);
+    static void copy_file(const std::filesystem::path &src, const std::filesystem::path &dst);
+    static void copy_dir(const std::filesystem::path &src, const std::filesystem::path &dst);
     void copy_default_configs();
 };
 } // namespace clrsync::core

src/core/error.hpp

@@ -1,207 +0,0 @@
-#ifndef CLRSYNC_CORE_ERROR_HPP
-#define CLRSYNC_CORE_ERROR_HPP
-
-#include <string>
-#include <variant>
-#include <optional>
-
-namespace clrsync::core
-{
-
-enum class error_code
-{
-    unknown,
-    
-    file_not_found,
-    file_open_failed,
-    file_write_failed,
-    file_read_failed,
-    dir_create_failed,
-    
-    parse_failed,
-    invalid_format,
-    
-    config_missing,
-    config_invalid,
-    
-    template_not_found,
-    template_load_failed,
-    template_apply_failed,
-    
-    palette_not_found,
-    palette_load_failed,
-    
-    init_failed,
-    invalid_arg,
-    resource_missing,
-};
-
-inline const char* error_code_string(error_code code)
-{
-    switch (code)
-    {
-        case error_code::unknown: return "Unknown error";
-        case error_code::file_not_found: return "File not found";
-        case error_code::file_open_failed: return "Failed to open file";
-        case error_code::file_write_failed: return "Failed to write file";
-        case error_code::file_read_failed: return "Failed to read file";
-        case error_code::dir_create_failed: return "Failed to create directory";
-        case error_code::parse_failed: return "Parse failed";
-        case error_code::invalid_format: return "Invalid format";
-        case error_code::config_missing: return "Configuration missing";
-        case error_code::config_invalid: return "Configuration invalid";
-        case error_code::template_not_found: return "Template not found";
-        case error_code::template_load_failed: return "Failed to load template";
-        case error_code::template_apply_failed: return "Failed to apply template";
-        case error_code::palette_not_found: return "Palette not found";
-        case error_code::palette_load_failed: return "Failed to load palette";
-        case error_code::init_failed: return "Initialization failed";
-        case error_code::invalid_arg: return "Invalid argument";
-        case error_code::resource_missing: return "Resource missing";
-        default: return "Unknown error code";
-    }
-}
-
-struct Error
-{
-    error_code code;
-    std::string message;
-    std::string context;
-    
-    Error(error_code c) : code(c), message(error_code_string(c)) {}
-    
-    Error(error_code c, std::string msg) 
-        : code(c), message(std::move(msg)) {}
-    
-    Error(error_code c, std::string msg, std::string ctx)
-        : code(c), message(std::move(msg)), context(std::move(ctx)) {}
-    
-    std::string description() const
-    {
-        if (context.empty())
-            return message;
-        return message + " [" + context + "]";
-    }
-};
-
-template<typename T>
-class [[nodiscard]] Result
-{
-private:
-    std::variant<T, Error> m_data;
-    
-public:
-    Result(T value) : m_data(std::move(value)) {}
-    
-    Result(Error error) : m_data(std::move(error)) {}
-    
-    bool is_ok() const { return std::holds_alternative<T>(m_data); }
-    
-    bool is_error() const { return std::holds_alternative<Error>(m_data); }
-    
-    explicit operator bool() const { return is_ok(); }
-    
-    T& value() & { return std::get<T>(m_data); }
-    const T& value() const & { return std::get<T>(m_data); }
-    T&& value() && { return std::get<T>(std::move(m_data)); }
-    
-    const Error& error() const { return std::get<Error>(m_data); }
-    
-    T value_or(T default_value) const
-    {
-        return is_ok() ? std::get<T>(m_data) : std::move(default_value);
-    }
-    
-    std::optional<T> ok() const
-    {
-        if (is_ok())
-            return std::get<T>(m_data);
-        return std::nullopt;
-    }
-    
-    std::optional<Error> err() const
-    {
-        if (is_error())
-            return std::get<Error>(m_data);
-        return std::nullopt;
-    }
-    
-    template<typename F>
-    auto map(F&& func) -> Result<decltype(func(std::declval<T>()))>
-    {
-        using U = decltype(func(std::declval<T>()));
-        if (is_ok())
-            return Result<U>(func(std::get<T>(m_data)));
-        return Result<U>(std::get<Error>(m_data));
-    }
-    
-    template<typename F>
-    auto and_then(F&& func) -> decltype(func(std::declval<T>()))
-    {
-        if (is_ok())
-            return func(std::get<T>(m_data));
-        using ResultType = decltype(func(std::declval<T>()));
-        return ResultType(std::get<Error>(m_data));
-    }
-};
-
-template<>
-class [[nodiscard]] Result<void>
-{
-private:
-    std::optional<Error> m_error;
-    
-public:
-    Result() : m_error(std::nullopt) {}
-    
-    Result(Error error) : m_error(std::move(error)) {}
-    
-    bool is_ok() const { return !m_error.has_value(); }
-    
-    bool is_error() const { return m_error.has_value(); }
-    
-    explicit operator bool() const { return is_ok(); }
-    
-    const Error& error() const { return *m_error; }
-    
-    std::optional<Error> err() const { return m_error; }
-};
-
-template<typename T>
-Result<T> Ok(T value)
-{
-    return Result<T>(std::move(value));
-}
-
-inline Result<void> Ok()
-{
-    return Result<void>();
-}
-
-template<typename T>
-Result<T> Err(Error error)
-{
-    return Result<T>(std::move(error));
-}
-
-template<typename T>
-Result<T> Err(error_code code)
-{
-    return Result<T>(Error(code));
-}
-
-template<typename T>
-Result<T> Err(error_code code, std::string message)
-{
-    return Result<T>(Error(code, std::move(message)));
-}
-
-template<typename T>
-Result<T> Err(error_code code, std::string message, std::string context)
-{
-    return Result<T>(Error(code, std::move(message), std::move(context)));
-}
-
-} // namespace clrsync::core
-
-#endif // CLRSYNC_CORE_ERROR_HPP

src/core/io/file.hpp

@@ -1,10 +1,10 @@
 #ifndef CLRSYNC_CORE_IO_FILE_HPP
 #define CLRSYNC_CORE_IO_FILE_HPP
+#include "core/common/error.hpp"
 #include <cstdint>
 #include <map>
 #include <string>
 #include <variant>
-#include <core/error.hpp>
 
 using value_type = std::variant<std::string, uint32_t, int, bool>;
 
@@ -16,7 +16,10 @@ class file
     file() = default;
     file(std::string path) {};
     virtual ~file() = default;
-    virtual Result<void> parse() { return Ok(); };
+    virtual Result<void> parse()
+    {
+        return Ok();
+    };
     virtual const std::string get_string_value(const std::string &section,
                                                const std::string &key) const
     {
@@ -42,7 +45,10 @@ class file
     virtual void insert_or_update_value(const std::string &section, const std::string &key,
                                         const value_type &value) {};
     virtual void remove_section(const std::string &section) {};
-    virtual Result<void> save_file() { return Ok(); };
+    virtual Result<void> save_file()
+    {
+        return Ok();
+    };
 };
 } // namespace clrsync::core::io
 #endif

src/core/io/toml_file.cpp

@@ -1,5 +1,5 @@
-#include "toml_file.hpp"
+#include "core/io/toml_file.hpp"
-#include "core/utils.hpp"
+#include "core/common/utils.hpp"
 #include <filesystem>
 #include <fstream>
 #include <vector>
@@ -113,9 +113,12 @@ void toml_file::remove_section(const std::string &section)
 
 Result<void> toml_file::save_file()
 {
-    try {
+    try
+    {
         std::filesystem::create_directories(std::filesystem::path(m_path).parent_path());
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception &e)
+    {
         return Err<void>(error_code::dir_create_failed, e.what(), m_path);
     }
 

src/core/io/toml_file.hpp

@@ -1,7 +1,7 @@
 #ifndef CLRSYNC_CORE_IO_TOML_FILE_HPP
 #define CLRSYNC_CORE_IO_TOML_FILE_HPP
-#include <core/io/file.hpp>
+#include "core/common/error.hpp"
-#include <core/error.hpp>
+#include "core/io/file.hpp"
 #include <string>
 #include <toml/toml.hpp>
 

src/core/palette/color.cpp

@@ -111,14 +111,17 @@ void color::from_hex_string(const std::string &str)
     if (str.empty() || str[0] != '#')
         throw std::invalid_argument("Invalid hex color format");
 
-    if (str.size() == 7) {
+    if (str.size() == 7)
+    {
         uint32_t rgb = static_cast<uint32_t>(std::stoul(str.substr(1), nullptr, 16));
         m_hex = (rgb << 8) | 0xFF;
     }
-    else if (str.size() == 9) {
+    else if (str.size() == 9)
+    {
         m_hex = static_cast<uint32_t>(std::stoul(str.substr(1), nullptr, 16));
     }
-    else {
+    else
+    {
         throw std::invalid_argument("Invalid hex color format");
     }
 }
@@ -137,30 +140,38 @@ const std::string color::to_hex_string_with_alpha() const
     return std::string(buffer);
 }
 
-std::string color::format(const std::string& field) const
+std::string color::format(const std::string &field) const
 {
     auto rgb = to_rgb();
     auto rgba = to_rgba();
     auto hslv = to_hsl();
     auto hslav = to_hsla();
 
-    if (field == "hex") return to_hex_string();
+    if (field == "hex")
-    if (field == "hex_stripped") {
+        return to_hex_string();
+    if (field == "hex_stripped")
+    {
         auto s = to_hex_string();
         return s.substr(1);
     }
 
-    if (field == "hexa") return to_hex_string_with_alpha();
+    if (field == "hexa")
-    if (field == "hexa_stripped") {
+        return to_hex_string_with_alpha();
+    if (field == "hexa_stripped")
+    {
         auto s = to_hex_string_with_alpha();
         return s.substr(1);
     }
 
-    if (field == "r") return std::to_string(rgb.r);
+    if (field == "r")
-    if (field == "g") return std::to_string(rgb.g);
+        return std::to_string(rgb.r);
-    if (field == "b") return std::to_string(rgb.b);
+    if (field == "g")
+        return std::to_string(rgb.g);
+    if (field == "b")
+        return std::to_string(rgb.b);
 
-    if (field == "a") {
+    if (field == "a")
+    {
         float af = rgba.a / 255.0f;
         return std::format("{:.2f}", af);
     }
@@ -169,9 +180,7 @@ std::string color::format(const std::string& field) const
         return std::format("rgb({},{},{})", rgb.r, rgb.g, rgb.b);
 
     if (field == "rgba")
-        return std::format("rgba({},{},{},{:.2f})",
+        return std::format("rgba({},{},{},{:.2f})", rgba.r, rgba.g, rgba.b, rgba.a / 255.0f);
-                           rgba.r, rgba.g, rgba.b,
-                           rgba.a / 255.0f);
 
     if (field == "h")
         return std::format("{:.0f}", hslv.h);
@@ -185,12 +194,10 @@ std::string color::format(const std::string& field) const
         return std::format("{:.2f}", hslav.a);
 
     if (field == "hsl")
-        return std::format("hsl({:.0f},{:.2f},{:.2f})",
+        return std::format("hsl({:.0f},{:.2f},{:.2f})", hslv.h, hslv.s, hslv.l);
-                           hslv.h, hslv.s, hslv.l);
 
     if (field == "hsla")
-        return std::format("hsla({:.0f},{:.2f},{:.2f},{:.2f})",
+        return std::format("hsla({:.0f},{:.2f},{:.2f},{:.2f})", hslav.h, hslav.s, hslav.l, hslav.a);
-                           hslav.h, hslav.s, hslav.l, hslav.a);
 
     throw std::runtime_error("Unknown color format: " + field);
 }

src/core/palette/color.hpp

@@ -60,7 +60,7 @@ class color
 
     const std::string to_hex_string_with_alpha() const;
 
-    std::string format(const std::string& field) const;
+    std::string format(const std::string &field) const;
 
     void set(uint32_t hex);
 

src/core/palette/color_keys.hpp

@@ -3,12 +3,12 @@
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
-#include <unordered_map>
 #include <string>
+#include <unordered_map>
 
 namespace clrsync::core
 {
-constexpr const char* COLOR_KEYS[] = {
+constexpr const char *COLOR_KEYS[] = {
     // General UI
     "background",
     "on_background",

src/core/palette/palette.hpp

@@ -4,8 +4,8 @@
 #include <string>
 #include <unordered_map>
 
-#include <core/palette/color.hpp>
+#include "core/palette/color.hpp"
-#include <core/palette/color_keys.hpp>
+#include "core/palette/color_keys.hpp"
 
 namespace clrsync::core
 {

src/core/palette/palette_file.hpp

@@ -5,9 +5,9 @@
 #include <cstdint>
 #include <string>
 
-#include <core/io/file.hpp>
+#include "core/io/file.hpp"
-#include <core/palette/color_keys.hpp>
+#include "core/palette/color_keys.hpp"
-#include <core/palette/palette.hpp>
+#include "core/palette/palette.hpp"
 
 #include <memory>
 

src/core/palette/palette_manager.hpp

@@ -1,14 +1,13 @@
 #ifndef CLRSYNC_CORE_PALETTE_PALETTE_MANAGER_HPP
 #define CLRSYNC_CORE_PALETTE_PALETTE_MANAGER_HPP
 
-#include "core/utils.hpp"
+#include "core/common/utils.hpp"
-#include <iostream>
 #include <string>
 #include <unordered_map>
 
-#include <core/config/config.hpp>
+#include "core/config/config.hpp"
-#include <core/palette/palette.hpp>
+#include "core/palette/palette.hpp"
-#include <core/palette/palette_file.hpp>
+#include "core/palette/palette_file.hpp"
 #include <filesystem>
 
 namespace clrsync::core

src/core/theme/template_manager.hpp

@@ -1,17 +1,15 @@
 #ifndef CLRSYNC_CORE_THEME_TEMPLATE_MANAGER_HPP
 #define CLRSYNC_CORE_THEME_TEMPLATE_MANAGER_HPP
 
-#include <core/config/config.hpp>
+#include "core/config/config.hpp"
-#include <core/theme/theme_template.hpp>
+#include "core/theme/theme_template.hpp"
 #include <string>
 #include <unordered_map>
 
-
 namespace clrsync::core
 {
 
-template <typename FileType>
+template <typename FileType> class template_manager
-class template_manager
 {
   public:
     template_manager() = default;

src/core/theme/theme_renderer.hpp

@@ -1,9 +1,10 @@
 #ifndef CLRSYNC_CORE_THEME_THEME_RENDERER_HPP
 #define CLRSYNC_CORE_THEME_THEME_RENDERER_HPP
-#include <core/config/config.hpp>
+#include "core/common/error.hpp"
-#include <core/palette/palette_manager.hpp>
+#include "core/config/config.hpp"
-#include <core/theme/template_manager.hpp>
+#include "core/palette/palette_manager.hpp"
-#include <core/error.hpp>
+#include "core/theme/template_manager.hpp"
+#include <iostream>
 #include <string>
 
 namespace clrsync::core
@@ -60,7 +61,8 @@ template <typename FileType> class theme_renderer
                 int result = std::system(tmpl.reload_command().c_str());
                 if (result != 0)
                 {
-                    std::cerr << "Warning: Command " << tmpl.reload_command() << " failed with code " << result << "\n";
+                    std::cerr << "Warning: Command " << tmpl.reload_command()
+                              << " failed with code " << result << "\n";
                 }
             }
         }

src/core/theme/theme_template.cpp

@@ -1,5 +1,5 @@
 #include "theme_template.hpp"
-#include "core/utils.hpp"
+#include "core/common/utils.hpp"
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -47,13 +47,15 @@ Result<void> theme_template::load_template()
 {
     if (!std::filesystem::exists(m_template_path))
     {
-        return Err<void>(error_code::template_not_found, "Template file is missing", m_template_path);
+        return Err<void>(error_code::template_not_found, "Template file is missing",
+                         m_template_path);
     }
 
     std::ifstream input(m_template_path, std::ios::binary);
     if (!input)
     {
-        return Err<void>(error_code::template_load_failed, "Failed to open template file", m_template_path);
+        return Err<void>(error_code::template_load_failed, "Failed to open template file",
+                         m_template_path);
     }
 
     m_template_data.assign(std::istreambuf_iterator<char>(input), std::istreambuf_iterator<char>());
@@ -64,7 +66,7 @@ void theme_template::apply_palette(const core::palette &palette)
 {
     m_processed_data = m_template_data;
 
-    for (const auto& [key, color] : palette.colors())
+    for (const auto &[key, color] : palette.colors())
     {
         // simple replacement: {foreground}
         replace_all(m_processed_data, "{" + key + "}", color.format("hex"));
@@ -96,7 +98,7 @@ Result<void> theme_template::save_output() const
     {
         std::filesystem::create_directories(std::filesystem::path(m_output_path).parent_path());
     }
-    catch (const std::exception& e)
+    catch (const std::exception &e)
     {
         return Err<void>(error_code::dir_create_failed, e.what(), m_output_path);
     }
@@ -104,13 +106,15 @@ Result<void> theme_template::save_output() const
     std::ofstream output(m_output_path, std::ios::binary);
     if (!output)
     {
-        return Err<void>(error_code::file_write_failed, "Failed to open output file for writing", m_output_path);
+        return Err<void>(error_code::file_write_failed, "Failed to open output file for writing",
+                         m_output_path);
     }
 
     output << m_processed_data;
     if (!output)
     {
-        return Err<void>(error_code::file_write_failed, "Failed to write to output file", m_output_path);
+        return Err<void>(error_code::file_write_failed, "Failed to write to output file",
+                         m_output_path);
     }
 
     return Ok();

src/core/theme/theme_template.hpp

@@ -1,8 +1,8 @@
 #ifndef clrsync_CORE_IO_THEME_TEMPLATE_HPP
 #define clrsync_CORE_IO_THEME_TEMPLATE_HPP
 
-#include <core/palette/palette.hpp>
+#include "core/common/error.hpp"
-#include <core/error.hpp>
+#include "core/palette/palette.hpp"
 #include <string>
 
 namespace clrsync::core

src/gui/CMakeLists.txt

@@ -1,22 +1,33 @@
 set(GUI_SOURCES
     main.cpp
-    color_scheme_editor.cpp
+        views/color_scheme_editor.cpp
-    color_table_renderer.cpp
+        views/color_table_renderer.cpp
-    preview_renderer.cpp
+        views/preview_renderer.cpp
-    theme_applier.cpp
+        controllers/theme_applier.cpp
-    template_editor.cpp
+        views/template_editor.cpp
-    palette_controller.cpp
+        controllers/palette_controller.cpp
-    template_controller.cpp
+        controllers/template_controller.cpp
-    imgui_helpers.cpp
+        helpers/imgui_helpers.cpp
-    imgui_helpers.hpp
+        helpers/imgui_helpers.hpp
-    about_window.cpp
+        views/about_window.cpp
-    settings_window.cpp
+        views/settings_window.cpp
-    font_loader.cpp
+        platform/windows/font_loader_windows.cpp
-    file_browser.cpp
+        platform/linux/font_loader_linux.cpp
+        platform/macos/font_loader_macos.cpp
+        platform/linux/file_browser_linux.cpp
+        platform/windows/file_browser_windows.cpp
         ${CMAKE_SOURCE_DIR}/lib/color_text_edit/TextEditor.cpp
+        platform/linux/font_loader_linux.cpp
+        platform/macos/font_loader_macos.cpp
+        platform/windows/font_loader_windows.cpp
+        backend/glfw_opengl.cpp
+        ui_manager.cpp
 )
-if(APPLE)
+
-    list(APPEND GUI_SOURCES file_browser_macos.mm)
+if(MACOS)
+    list(APPEND GUI_SOURCES
+        platform/macos/file_browser_macos.mm
+    )
 endif()
 
 if(WIN32)

src/gui/about_window.hpp

@@ -1,21 +0,0 @@
-#ifndef CLRSYNC_GUI_ABOUT_WINDOW_HPP
-#define CLRSYNC_GUI_ABOUT_WINDOW_HPP
-
-#include "core/palette/palette.hpp"
-
-class about_window
-{
-public:
-    about_window();
-    void render(const clrsync::core::palette& pal);
-    void render() { render(m_default_palette); }
-    void show() { m_visible = true; }
-    void hide() { m_visible = false; }
-    bool is_visible() const { return m_visible; }
-
-private:
-    bool m_visible{false};
-    clrsync::core::palette m_default_palette;
-};
-
-#endif // CLRSYNC_GUI_ABOUT_WINDOW_HPP

src/gui/backend/backend.hpp

@@ -0,0 +1,38 @@
+#ifndef CLRSYNC_BACKEND_HPP
+#define CLRSYNC_BACKEND_HPP
+
+#include <string>
+
+namespace clrsync::gui::backend{
+
+    struct window_config{
+        std::string title = "clrsync";
+        int width = 1280;
+        int height = 720;
+        bool resizable = true;
+        bool decorated = true;
+        bool transparent_framebuffer = true;
+        float clear_color[4] = {0.1f, 0.1f, 0.1f, 0.0f};
+    };
+    class backend_interface{
+    public:
+        virtual ~backend_interface() = default;
+
+        virtual bool initialize(const window_config& config) = 0;
+        virtual void shutdown() = 0;
+        virtual bool should_close() const = 0;
+        virtual void begin_frame() = 0;
+        virtual void end_frame() = 0;
+
+        virtual void* get_native_window() const = 0;
+        virtual void* get_graphics_context() const = 0;
+        
+        virtual bool init_imgui_backend() = 0;
+        virtual void shutdown_imgui_backend() = 0;
+        virtual void imgui_new_frame() = 0;
+        virtual void imgui_render_draw_data(void* draw_data) = 0;
+    };
+
+}
+
+#endif // CLRSYNC_BACKEND_HPP

src/gui/backend/glfw_opengl.cpp

@@ -0,0 +1,141 @@
+#include "gui/backend/glfw_opengl.hpp"
+#include <iostream>
+#include <GLFW/glfw3.h>
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+
+namespace clrsync::gui::backend
+{
+
+glfw_opengl_backend::glfw_opengl_backend() = default;
+
+glfw_opengl_backend::~glfw_opengl_backend()
+{
+    glfw_opengl_backend::shutdown();
+}
+
+bool glfw_opengl_backend::initialize(const window_config &config)
+{
+    glfwSetErrorCallback([](int error, const char* description) {
+        std::cerr << "GLFW Error " << error << ": " << description << std::endl;
+    });
+    
+    if (!glfwInit())
+    {
+        std::cerr << "Failed to initialize GLFW" << std::endl;
+        return false;
+    }
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+#else
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+#endif
+    glfwWindowHint(GLFW_RESIZABLE, config.resizable ? GLFW_TRUE : GLFW_FALSE);
+    glfwWindowHint(GLFW_DECORATED, config.decorated ? GLFW_TRUE : GLFW_FALSE);
+    glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, config.transparent_framebuffer ? GLFW_TRUE : GLFW_FALSE);
+
+    m_window = glfwCreateWindow(config.width, config.height, config.title.c_str(), nullptr, nullptr);
+    if (!m_window)
+    {
+        std::cerr << "Failed to create GLFW window" << std::endl;
+        glfwTerminate();
+        return false;
+    }
+
+    glfwMakeContextCurrent(m_window);
+    glfwSwapInterval(1);
+
+    return true;
+}
+
+void glfw_opengl_backend::shutdown()
+{
+    if (m_window)
+    {
+        glfwDestroyWindow(m_window);
+        m_window = nullptr;
+    }
+    glfwTerminate();
+}
+
+bool glfw_opengl_backend::should_close() const
+{
+    return m_window && glfwWindowShouldClose(m_window);
+}
+
+void glfw_opengl_backend::begin_frame()
+{
+    glfwPollEvents();
+    
+    if (m_window)
+    {
+        int display_w, display_h;
+        glfwGetFramebufferSize(m_window, &display_w, &display_h);
+        glViewport(0, 0, display_w, display_h);
+        glClearColor(0.1f, 0.1f, 0.1f, 0.0f);
+        glClear(GL_COLOR_BUFFER_BIT);
+    }
+}
+
+void glfw_opengl_backend::end_frame()
+{
+    if (m_window)
+    {
+        glfwSwapBuffers(m_window);
+    }
+}
+
+void *glfw_opengl_backend::get_native_window() const
+{
+    return static_cast<void *>(m_window);
+}
+
+void *glfw_opengl_backend::get_graphics_context() const
+{
+    return static_cast<void *>(m_window);
+}
+
+bool glfw_opengl_backend::init_imgui_backend()
+{
+    if (!m_window)
+        return false;
+    
+    if (!ImGui_ImplGlfw_InitForOpenGL(m_window, true))
+        return false;
+    
+#ifdef __APPLE__
+    const char* glsl_version = "#version 150";
+#else
+    const char* glsl_version = "#version 120";
+#endif
+    
+    if (!ImGui_ImplOpenGL3_Init(glsl_version))
+    {
+        ImGui_ImplGlfw_Shutdown();
+        return false;
+    }
+    
+    return true;
+}
+
+void glfw_opengl_backend::shutdown_imgui_backend()
+{
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+}
+
+void glfw_opengl_backend::imgui_new_frame()
+{
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+}
+
+void glfw_opengl_backend::imgui_render_draw_data(void* draw_data)
+{
+    ImGui_ImplOpenGL3_RenderDrawData(static_cast<ImDrawData*>(draw_data));
+}
+
+} // namespace clrsync::gui::backend

src/gui/backend/glfw_opengl.hpp

@@ -0,0 +1,36 @@
+#ifndef CLRSYNC_GLFW_OPENGL_HPP
+#define CLRSYNC_GLFW_OPENGL_HPP
+
+#define GL_SILENCE_DEPRECATION
+
+#include <GLFW/glfw3.h>
+
+#include "gui/backend/backend.hpp"
+
+namespace clrsync::gui::backend{
+
+    class glfw_opengl_backend : public backend_interface{
+    public:
+        glfw_opengl_backend();
+        ~glfw_opengl_backend();
+
+        bool initialize(const window_config& config) override;
+        void shutdown() override;
+        bool should_close() const override;
+        void begin_frame() override;
+        void end_frame() override;
+
+        void* get_native_window() const override;
+        void* get_graphics_context() const override;
+        
+        bool init_imgui_backend() override;
+        void shutdown_imgui_backend() override;
+        void imgui_new_frame() override;
+        void imgui_render_draw_data(void* draw_data) override;
+
+    private:
+        GLFWwindow* m_window = nullptr;
+    };
+}
+
+#endif // CLRSYNC_GLFW_OPENGL_HPP

src/gui/color_scheme_editor.hpp

@@ -1,35 +0,0 @@
-#ifndef CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
-#define CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
-
-#include "palette_controller.hpp"
-#include "color_table_renderer.hpp"
-#include "preview_renderer.hpp"
-
-class template_editor;
-class settings_window;
-
-class color_scheme_editor
-{
-public:
-    color_scheme_editor();
-    
-    void render_controls_and_colors();
-    void render_preview();
-    void set_template_editor(template_editor* editor) { m_template_editor = editor; }
-    void set_settings_window(settings_window* window) { m_settings_window = window; }
-    const palette_controller& controller() const { return m_controller; }
-
-private:
-    void render_controls();
-    void apply_themes();
-    void notify_palette_changed();
-
-    palette_controller m_controller;
-    color_table_renderer m_color_table;
-    preview_renderer m_preview;
-    template_editor* m_template_editor{nullptr};
-    settings_window* m_settings_window{nullptr};
-    bool m_show_delete_confirmation{false};
-};
-
-#endif // CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP

src/gui/color_table_renderer.hpp

@@ -1,30 +0,0 @@
-#ifndef CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP
-#define CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP
-
-#include "core/palette/palette.hpp"
-#include "palette_controller.hpp"
-#include <functional>
-#include <string>
-
-class color_table_renderer
-{
-public:
-    using OnColorChangedCallback = std::function<void()>;
-    
-    void render(const clrsync::core::palette& palette, 
-                palette_controller& controller,
-                const OnColorChangedCallback& on_changed);
-
-private:
-    void render_color_row(const std::string& name,
-                         const clrsync::core::palette& palette,
-                         palette_controller& controller,
-                         const OnColorChangedCallback& on_changed);
-    
-    bool matches_filter(const std::string& name) const;
-    
-    char m_filter_text[128] = {0};
-    bool m_show_only_modified{false};
-};
-
-#endif // CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP

src/gui/controllers/palette_controller.cpp

@@ -1,4 +1,4 @@
-#include "palette_controller.hpp"
+#include "gui/controllers/palette_controller.hpp"
 #include "core/config/config.hpp"
 #include "core/theme/theme_renderer.hpp"
 
@@ -13,26 +13,30 @@ palette_controller::palette_controller()
 
     auto default_theme = clrsync::core::config::instance().default_theme();
     auto it = m_palettes.find(default_theme);
-    if (it != m_palettes.end()) {
+    if (it != m_palettes.end())
+    {
         m_current_palette = it->second;
-    } else {
+    }
+    else
+    {
         m_current_palette = m_palettes.begin()->second;
     }
 }
 
-void palette_controller::select_palette(const std::string& name)
+void palette_controller::select_palette(const std::string &name)
 {
     auto it = m_palettes.find(name);
-    if (it != m_palettes.end()) {
+    if (it != m_palettes.end())
+    {
         m_current_palette = it->second;
     }
 }
 
-void palette_controller::create_palette(const std::string& name)
+void palette_controller::create_palette(const std::string &name)
 {
     clrsync::core::palette new_palette(name);
 
-    for (const auto& [key, hex_value] : clrsync::core::DEFAULT_COLORS)
+    for (const auto &[key, hex_value] : clrsync::core::DEFAULT_COLORS)
     {
         new_palette.set_color(key, clrsync::core::color(hex_value));
     }
@@ -63,7 +67,7 @@ void palette_controller::apply_current_theme() const
     (void)theme_renderer.apply_theme(m_current_palette.name());
 }
 
-void palette_controller::set_color(const std::string& key, const clrsync::core::color& color)
+void palette_controller::set_color(const std::string &key, const clrsync::core::color &color)
 {
     m_current_palette.set_color(key, color);
 }

src/gui/controllers/palette_controller.hpp

@@ -6,21 +6,28 @@
 #include <string>
 #include <unordered_map>
 
-class palette_controller {
+class palette_controller
-public:
+{
+  public:
     palette_controller();
 
-    const clrsync::core::palette& current_palette() const { return m_current_palette; }
+    const clrsync::core::palette &current_palette() const
-    const std::unordered_map<std::string, clrsync::core::palette>& palettes() const { return m_palettes; }
+    {
+        return m_current_palette;
+    }
+    const std::unordered_map<std::string, clrsync::core::palette> &palettes() const
+    {
+        return m_palettes;
+    }
 
-    void select_palette(const std::string& name);
+    void select_palette(const std::string &name);
-    void create_palette(const std::string& name);
+    void create_palette(const std::string &name);
     void save_current_palette();
     void delete_current_palette();
     void apply_current_theme() const;
-    void set_color(const std::string& key, const clrsync::core::color& color);
+    void set_color(const std::string &key, const clrsync::core::color &color);
 
-private:
+  private:
     void reload_palettes();
 
     clrsync::core::palette_manager<clrsync::core::io::toml_file> m_palette_manager;

src/gui/controllers/template_controller.cpp

@@ -1,4 +1,4 @@
-#include "template_controller.hpp"
+#include "gui/controllers/template_controller.hpp"
 #include "core/config/config.hpp"
 
 template_controller::template_controller()
@@ -6,46 +6,52 @@ template_controller::template_controller()
     m_templates = m_template_manager.templates();
 }
 
-void template_controller::set_template_enabled(const std::string& key, bool enabled)
+void template_controller::set_template_enabled(const std::string &key, bool enabled)
 {
     auto it = m_templates.find(key);
-    if (it != m_templates.end()) {
+    if (it != m_templates.end())
+    {
         it->second.set_enabled(enabled);
         (void)clrsync::core::config::instance().update_template(key, it->second);
     }
 }
 
-void template_controller::set_template_input_path(const std::string& key, const std::string& path)
+void template_controller::set_template_input_path(const std::string &key, const std::string &path)
 {
     auto it = m_templates.find(key);
-    if (it != m_templates.end()) {
+    if (it != m_templates.end())
+    {
         it->second.set_template_path(path);
         (void)clrsync::core::config::instance().update_template(key, it->second);
     }
 }
 
-void template_controller::set_template_output_path(const std::string& key, const std::string& path)
+void template_controller::set_template_output_path(const std::string &key, const std::string &path)
 {
     auto it = m_templates.find(key);
-    if (it != m_templates.end()) {
+    if (it != m_templates.end())
+    {
         it->second.set_output_path(path);
         (void)clrsync::core::config::instance().update_template(key, it->second);
     }
 }
 
-void template_controller::set_template_reload_command(const std::string& key, const std::string& cmd)
+void template_controller::set_template_reload_command(const std::string &key,
+                                                      const std::string &cmd)
 {
     auto it = m_templates.find(key);
-    if (it != m_templates.end()) {
+    if (it != m_templates.end())
+    {
         it->second.set_reload_command(cmd);
         (void)clrsync::core::config::instance().update_template(key, it->second);
     }
 }
 
-bool template_controller::remove_template(const std::string& key)
+bool template_controller::remove_template(const std::string &key)
 {
     auto result = clrsync::core::config::instance().remove_template(key);
-    if (result) {
+    if (result)
+    {
         m_templates.erase(key);
         return true;
     }

src/gui/controllers/template_controller.hpp

@@ -1,24 +1,29 @@
 #ifndef CLRSYNC_GUI_TEMPLATE_CONTROLLER_HPP
 #define CLRSYNC_GUI_TEMPLATE_CONTROLLER_HPP
 
-#include "core/theme/theme_template.hpp"
-#include "core/theme/template_manager.hpp"
 #include "core/io/toml_file.hpp"
+#include "core/theme/template_manager.hpp"
+#include "core/theme/theme_template.hpp"
 #include <string>
 #include <unordered_map>
 
-class template_controller {
+class template_controller
-public:
+{
+  public:
     template_controller();
-    [[nodiscard]] const std::unordered_map<std::string, clrsync::core::theme_template>& templates() const { return m_templates; }
+    [[nodiscard]] const std::unordered_map<std::string, clrsync::core::theme_template> &templates()
-    void set_template_enabled(const std::string& key, bool enabled);
+        const
-    void set_template_input_path(const std::string& key, const std::string& path);
+    {
-    void set_template_output_path(const std::string& key, const std::string& path);
+        return m_templates;
-    void set_template_reload_command(const std::string& key, const std::string& cmd);
+    }
-    bool remove_template(const std::string& key);
+    void set_template_enabled(const std::string &key, bool enabled);
+    void set_template_input_path(const std::string &key, const std::string &path);
+    void set_template_output_path(const std::string &key, const std::string &path);
+    void set_template_reload_command(const std::string &key, const std::string &cmd);
+    bool remove_template(const std::string &key);
     void refresh();
 
-private:
+  private:
     clrsync::core::template_manager<clrsync::core::io::toml_file> m_template_manager;
     std::unordered_map<std::string, clrsync::core::theme_template> m_templates;
 };

src/gui/controllers/theme_applier.cpp

@@ -1,10 +1,10 @@
-#include "theme_applier.hpp"
+#include "gui/controllers/theme_applier.hpp"
 #include "imgui.h"
 
 namespace theme_applier
 {
 
-static uint32_t get_color_u32(const clrsync::core::palette& current, const std::string &key)
+static uint32_t get_color_u32(const clrsync::core::palette &current, const std::string &key)
 {
     const auto &col = current.get_color(key);
     const uint32_t hex = col.hex();
@@ -16,7 +16,7 @@ static uint32_t get_color_u32(const clrsync::core::palette& current, const std::
     return (a << 24) | (b << 16) | (g << 8) | r;
 }
 
-void apply_to_editor(TextEditor& editor, const clrsync::core::palette& current)
+void apply_to_editor(TextEditor &editor, const clrsync::core::palette &current)
 {
     auto palette = editor.GetPalette();
 
@@ -26,32 +26,40 @@ void apply_to_editor(TextEditor& editor, const clrsync::core::palette& current)
     palette[int(TextEditor::PaletteIndex::String)] = get_color_u32(current, "editor_string");
     palette[int(TextEditor::PaletteIndex::CharLiteral)] = get_color_u32(current, "editor_string");
     palette[int(TextEditor::PaletteIndex::Punctuation)] = get_color_u32(current, "editor_main");
-    palette[int(TextEditor::PaletteIndex::Preprocessor)] = get_color_u32(current, "editor_emphasis");
+    palette[int(TextEditor::PaletteIndex::Preprocessor)] =
+        get_color_u32(current, "editor_emphasis");
     palette[int(TextEditor::PaletteIndex::Identifier)] = get_color_u32(current, "editor_main");
     palette[int(TextEditor::PaletteIndex::KnownIdentifier)] = get_color_u32(current, "editor_link");
-    palette[int(TextEditor::PaletteIndex::PreprocIdentifier)] = get_color_u32(current, "editor_link");
+    palette[int(TextEditor::PaletteIndex::PreprocIdentifier)] =
+        get_color_u32(current, "editor_link");
 
     palette[int(TextEditor::PaletteIndex::Comment)] = get_color_u32(current, "editor_comment");
-    palette[int(TextEditor::PaletteIndex::MultiLineComment)] = get_color_u32(current, "editor_comment");
+    palette[int(TextEditor::PaletteIndex::MultiLineComment)] =
+        get_color_u32(current, "editor_comment");
 
-    palette[int(TextEditor::PaletteIndex::Background)] = get_color_u32(current, "editor_background");
+    palette[int(TextEditor::PaletteIndex::Background)] =
+        get_color_u32(current, "editor_background");
     palette[int(TextEditor::PaletteIndex::Cursor)] = get_color_u32(current, "cursor");
 
     palette[int(TextEditor::PaletteIndex::Selection)] = get_color_u32(current, "editor_selected");
     palette[int(TextEditor::PaletteIndex::ErrorMarker)] = get_color_u32(current, "editor_error");
     palette[int(TextEditor::PaletteIndex::Breakpoint)] = get_color_u32(current, "editor_error");
 
-    palette[int(TextEditor::PaletteIndex::LineNumber)] = get_color_u32(current, "editor_line_number");
+    palette[int(TextEditor::PaletteIndex::LineNumber)] =
+        get_color_u32(current, "editor_line_number");
 
-    palette[int(TextEditor::PaletteIndex::CurrentLineFill)] = get_color_u32(current, "surface_variant");
+    palette[int(TextEditor::PaletteIndex::CurrentLineFill)] =
-    palette[int(TextEditor::PaletteIndex::CurrentLineFillInactive)] = get_color_u32(current, "surface");
+        get_color_u32(current, "surface_variant");
+    palette[int(TextEditor::PaletteIndex::CurrentLineFillInactive)] =
+        get_color_u32(current, "surface");
 
-    palette[int(TextEditor::PaletteIndex::CurrentLineEdge)] = get_color_u32(current, "border_focused");
+    palette[int(TextEditor::PaletteIndex::CurrentLineEdge)] =
+        get_color_u32(current, "border_focused");
 
     editor.SetPalette(palette);
 }
 
-void apply_to_imgui(const clrsync::core::palette& current)
+void apply_to_imgui(const clrsync::core::palette &current)
 {
     auto getColor = [&](const std::string &key) -> ImVec4 {
         const auto &col = current.get_color(key);
@@ -138,7 +146,8 @@ void apply_to_imgui(const clrsync::core::palette& current)
         ImVec4(border.x * 0.7f, border.y * 0.7f, border.z * 0.7f, border.w);
 
     style.Colors[ImGuiCol_TableRowBg] = ImVec4(0, 0, 0, 0);
-    style.Colors[ImGuiCol_TableRowBgAlt] = ImVec4(onSurfaceVariant.x, onSurfaceVariant.y, onSurfaceVariant.z, 0.06f);
+    style.Colors[ImGuiCol_TableRowBgAlt] =
+        ImVec4(onSurfaceVariant.x, onSurfaceVariant.y, onSurfaceVariant.z, 0.06f);
 
     style.Colors[ImGuiCol_Separator] = border;
     style.Colors[ImGuiCol_SeparatorHovered] = accent;

src/gui/controllers/theme_applier.hpp

@@ -1,13 +1,13 @@
 #ifndef CLRSYNC_GUI_THEME_APPLIER_HPP
 #define CLRSYNC_GUI_THEME_APPLIER_HPP
 
-#include "core/palette/palette.hpp"
 #include "color_text_edit/TextEditor.h"
+#include "core/palette/palette.hpp"
 
 namespace theme_applier
 {
-    void apply_to_imgui(const clrsync::core::palette& pal);
+void apply_to_imgui(const clrsync::core::palette &pal);
-    void apply_to_editor(TextEditor& editor, const clrsync::core::palette& pal);
+void apply_to_editor(TextEditor &editor, const clrsync::core::palette &pal);
-}
+} // namespace theme_applier
 
 #endif // CLRSYNC_GUI_THEME_APPLIER_HPP

src/gui/file_browser.cpp

@@ -1,263 +0,0 @@
-#include "file_browser.hpp"
-#include <filesystem>
-
-#ifdef _WIN32
-#include <windows.h>
-#include <commdlg.h>
-#include <shlobj.h>
-#include <shlwapi.h>
-#include <cstring>
-
-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 "";
-}
-
-}
-
-#elif !defined(__APPLE__)
-
-#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;
-}
-
-}
-
-#endif

src/gui/file_browser.hpp

@@ -1,20 +0,0 @@
-#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 = "");
-}
-
-#endif // CLRSYNC_GUI_FILE_BROWSER_HPP

src/gui/font_loader.cpp

@@ -1,333 +0,0 @@
-#include "font_loader.hpp"
-#include "core/config/config.hpp"
-#include "imgui_internal.h"
-#include <imgui.h>
-#include <algorithm>
-
-#if defined(_WIN32)
-
-#include <algorithm>
-#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;
-}
-#endif
-
-#if defined(__APPLE__)
-
-#include <CoreText/CoreText.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;
-}
-
-#endif
-
-#if !defined(_WIN32) && !defined(__APPLE__)
-
-#include <fontconfig/fontconfig.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;
-}
-
-#endif
-
-std::string font_loader::find_font_path(const char* font_name)
-{
-#if defined(_WIN32)
-    return find_font_windows(font_name);
-
-#elif defined(__APPLE__)
-    (void)font_name;
-    return {};
-
-#else
-    return find_font_linux(font_name);
-
-#endif
-}
-
-ImFont* font_loader::load_font(const char* font_name, float size_px)
-{
-#if defined(__APPLE__)
-    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
-    );
-
-#else
-    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
-    );
-#endif
-}
-
-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;
-
-#if defined(_WIN32)
-    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");
-
-#elif defined(__APPLE__)
-    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);
-        }
-    }
-
-#else
-    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);
-#endif
-
-    std::sort(fonts.begin(), fonts.end());
-    return fonts;
-}

src/gui/helpers/imgui_helpers.cpp

@@ -2,7 +2,7 @@
 #include <string>
 
 #include "GLFW/glfw3.h"
-#include "gui/settings_window.hpp"
+#include "gui/views/settings_window.hpp"
 #include "imgui_impl_glfw.h"
 #include "imgui_impl_opengl3.h"
 
@@ -10,9 +10,9 @@
 
 #include "imgui_internal.h"
 
-GLFWwindow * init_glfw()
+GLFWwindow *init_glfw()
 {
-    glfwSetErrorCallback([](int error, const char* description) {
+    glfwSetErrorCallback([](int error, const char *description) {
         std::cerr << "GLFW Error " << error << ": " << description << std::endl;
     });
 
@@ -23,14 +23,14 @@ GLFWwindow * init_glfw()
     }
 
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    #ifdef __APPLE__
+#ifdef __APPLE__
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
-    #else
+#else
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
-    #endif
+#endif
     glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);
 
-    GLFWwindow* w = glfwCreateWindow(1280, 720, "clrsync", nullptr, nullptr);
+    GLFWwindow *w = glfwCreateWindow(1280, 720, "clrsync", nullptr, nullptr);
     if (!w)
     {
         std::cerr << "Failed to create GLFW window\n";
@@ -42,22 +42,22 @@ GLFWwindow * init_glfw()
     return w;
 }
 
-void init_imgui(GLFWwindow* window, const std::string& ini_path)
+void init_imgui(GLFWwindow *window, const std::string &ini_path)
 {
     IMGUI_CHECKVERSION();
     ImGui::CreateContext();
 
-    ImGuiIO& io = ImGui::GetIO();
+    ImGuiIO &io = ImGui::GetIO();
     io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
     io.IniFilename = ini_path.c_str();
 
     ImGui::StyleColorsDark();
     ImGui_ImplGlfw_InitForOpenGL(window, true);
-    #ifdef __APPLE__
+#ifdef __APPLE__
     ImGui_ImplOpenGL3_Init("#version 150");
-    #else
+#else
     ImGui_ImplOpenGL3_Init("#version 120");
-    #endif
+#endif
 }
 
 void begin_frame()
@@ -67,7 +67,7 @@ void begin_frame()
     ImGui::NewFrame();
 }
 
-void render_menu_bar(about_window* about, settings_window* settings)
+void render_menu_bar(about_window *about, settings_window *settings)
 {
     if (ImGui::BeginMainMenuBar())
     {
@@ -99,25 +99,21 @@ void render_menu_bar(about_window* about, settings_window* settings)
     }
 }
 
-void setup_main_dockspace(bool& first_time)
+void setup_main_dockspace(bool &first_time)
 {
-    const ImGuiViewport* viewport = ImGui::GetMainViewport();
+    const ImGuiViewport *viewport = ImGui::GetMainViewport();
     ImGui::SetNextWindowPos(viewport->Pos);
     ImGui::SetNextWindowSize(viewport->Size);
     ImGui::SetNextWindowViewport(viewport->ID);
 
-    constexpr ImGuiWindowFlags flags =
+    constexpr ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse |
-        ImGuiWindowFlags_NoTitleBar |
+                                       ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
-        ImGuiWindowFlags_NoCollapse |
-        ImGuiWindowFlags_NoResize |
-        ImGuiWindowFlags_NoMove |
                                        ImGuiWindowFlags_NoBringToFrontOnFocus |
-        ImGuiWindowFlags_NoNavFocus |
+                                       ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_MenuBar;
-        ImGuiWindowFlags_MenuBar;
 
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0,0));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
     ImGui::Begin("MainDockSpace", nullptr, flags);
     ImGui::PopStyleVar(3);
 
@@ -134,7 +130,7 @@ void setup_main_dockspace(bool& first_time)
         ImGuiID center, right;
         ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Right, 0.5f, &right, &center);
 
-        ImGuiDockNode* center_node = ImGui::DockBuilderGetNode(center);
+        ImGuiDockNode *center_node = ImGui::DockBuilderGetNode(center);
         if (center_node)
         {
             center_node->LocalFlags |= ImGuiDockNodeFlags_CentralNode;
@@ -147,11 +143,11 @@ void setup_main_dockspace(bool& first_time)
         ImGui::DockBuilderFinish(dockspace_id);
     }
 
-    ImGui::DockSpace(dockspace_id, ImVec2{0,0}, ImGuiDockNodeFlags_None);
+    ImGui::DockSpace(dockspace_id, ImVec2{0, 0}, ImGuiDockNodeFlags_None);
     ImGui::End();
 }
 
-void end_frame(GLFWwindow* window)
+void end_frame(GLFWwindow *window)
 {
     ImGui::Render();
     int w, h;
@@ -164,7 +160,7 @@ void end_frame(GLFWwindow* window)
     glfwSwapBuffers(window);
 }
 
-void shutdown(GLFWwindow* window)
+void shutdown(GLFWwindow *window)
 {
     ImGui_ImplOpenGL3_Shutdown();
     ImGui_ImplGlfw_Shutdown();
@@ -176,7 +172,8 @@ void shutdown(GLFWwindow* window)
 namespace palette_utils
 {
 
-ImVec4 get_color(const clrsync::core::palette& pal, const std::string& key, const std::string& fallback)
+ImVec4 get_color(const clrsync::core::palette &pal, const std::string &key,
+                 const std::string &fallback)
 {
     auto colors = pal.colors();
     if (colors.empty())
@@ -190,7 +187,7 @@ ImVec4 get_color(const clrsync::core::palette& pal, const std::string& key, cons
 
     if (it != colors.end())
     {
-        const auto& col = it->second;
+        const auto &col = it->second;
         const uint32_t hex = col.hex();
         const float r = ((hex >> 24) & 0xFF) / 255.0f;
         const float g = ((hex >> 16) & 0xFF) / 255.0f;
@@ -201,7 +198,8 @@ ImVec4 get_color(const clrsync::core::palette& pal, const std::string& key, cons
     return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
 }
 
-uint32_t get_color_u32(const clrsync::core::palette& pal, const std::string& key, const std::string& fallback)
+uint32_t get_color_u32(const clrsync::core::palette &pal, const std::string &key,
+                       const std::string &fallback)
 {
     auto colors = pal.colors();
     if (colors.empty())
@@ -215,7 +213,7 @@ uint32_t get_color_u32(const clrsync::core::palette& pal, const std::string& key
 
     if (it != colors.end())
     {
-        const auto& col = it->second;
+        const auto &col = it->second;
         const uint32_t hex = col.hex();
         const uint32_t r = (hex >> 24) & 0xFF;
         const uint32_t g = (hex >> 16) & 0xFF;
@@ -226,15 +224,17 @@ uint32_t get_color_u32(const clrsync::core::palette& pal, const std::string& key
     return 0xFFFFFFFF;
 }
 
-bool render_delete_confirmation_popup(const std::string& popup_title, const std::string& item_name, 
+bool render_delete_confirmation_popup(const std::string &popup_title, const std::string &item_name,
-                                      const std::string& item_type, const clrsync::core::palette& pal,
+                                      const std::string &item_type,
-                                      const std::function<void()>& on_delete)
+                                      const clrsync::core::palette &pal,
+                                      const std::function<void()> &on_delete)
 {
     bool result = false;
     if (ImGui::BeginPopupModal(popup_title.c_str(), nullptr, ImGuiWindowFlags_AlwaysAutoResize))
     {
         ImVec4 warning_color = get_color(pal, "warning", "accent");
-        ImGui::TextColored(warning_color, "Are you sure you want to delete '%s'?", item_name.c_str());
+        ImGui::TextColored(warning_color, "Are you sure you want to delete '%s'?",
+                           item_name.c_str());
         ImGui::Text("This action cannot be undone.");
 
         ImGui::Spacing();
@@ -263,4 +263,4 @@ bool render_delete_confirmation_popup(const std::string& popup_title, const std:
     return result;
 }
 
-}
+} // namespace palette_utils

src/gui/helpers/imgui_helpers.hpp

@@ -0,0 +1,42 @@
+#ifndef CLRSYNC_IMGUI_HELPERS_HPP
+#define CLRSYNC_IMGUI_HELPERS_HPP
+
+#include "core/palette/palette.hpp"
+#include "gui/views/about_window.hpp"
+#include "imgui.h"
+#include <functional>
+#include <string>
+
+struct GLFWwindow;
+class settings_window;
+
+GLFWwindow *init_glfw();
+void init_imgui(GLFWwindow *window, const std::string &ini_path);
+void begin_frame();
+void setup_main_dockspace(bool &first_time);
+void end_frame(GLFWwindow *window);
+void shutdown(GLFWwindow *window);
+void render_menu_bar(about_window *about, settings_window *settings);
+
+namespace palette_utils
+{
+ImVec4 get_color(const clrsync::core::palette &pal, const std::string &key,
+                 const std::string &fallback = "");
+uint32_t get_color_u32(const clrsync::core::palette &pal, const std::string &key,
+                       const std::string &fallback = "");
+bool render_delete_confirmation_popup(const std::string &popup_title, const std::string &item_name,
+                                      const std::string &item_type,
+                                      const clrsync::core::palette &pal,
+                                      const std::function<void()> &on_delete);
+} // namespace palette_utils
+
+namespace imgui_helpers
+{
+inline ImVec4 get_palette_color(const clrsync::core::palette &pal, const std::string &key,
+                                const std::string &fallback = "")
+{
+    return palette_utils::get_color(pal, key, fallback);
+}
+} // namespace imgui_helpers
+
+#endif // CLRSYNC_IMGUI_HELPERS_HPP

src/gui/imgui_helpers.hpp

@@ -1,37 +0,0 @@
-#ifndef CLRSYNC_IMGUI_HELPERS_HPP
-#define CLRSYNC_IMGUI_HELPERS_HPP
-
-#include "gui/about_window.hpp"
-#include "core/palette/palette.hpp"
-#include "imgui.h"
-#include <functional>
-#include <string>
-
-struct GLFWwindow;
-class settings_window;
-
-GLFWwindow * init_glfw();
-void init_imgui(GLFWwindow* window, const std::string& ini_path);
-void begin_frame();
-void setup_main_dockspace(bool& first_time);
-void end_frame(GLFWwindow* window);
-void shutdown(GLFWwindow* window);
-void render_menu_bar(about_window* about, settings_window* settings);
-
-namespace palette_utils 
-{
-    ImVec4 get_color(const clrsync::core::palette& pal, const std::string& key, const std::string& fallback = "");
-    uint32_t get_color_u32(const clrsync::core::palette& pal, const std::string& key, const std::string& fallback = "");
-    bool render_delete_confirmation_popup(const std::string& popup_title, const std::string& item_name, 
-                                          const std::string& item_type, const clrsync::core::palette& pal,
-                                          const std::function<void()>& on_delete);
-}
-
-namespace imgui_helpers 
-{
-    inline ImVec4 get_palette_color(const clrsync::core::palette& pal, const std::string& key, const std::string& fallback = "") {
-        return palette_utils::get_color(pal, key, fallback);
-    }
-}
-
-#endif // CLRSYNC_IMGUI_HELPERS_HPP

src/gui/main.cpp

@@ -1,23 +1,24 @@
+#include <iostream>
 #include <memory>
 
 #include <GLFW/glfw3.h>
 #include <GLFW/glfw3native.h>
 
-
+#include "core/common/error.hpp"
+#include "core/common/utils.hpp"
 #include "core/config/config.hpp"
 #include "core/io/toml_file.hpp"
-#include "core/utils.hpp"
-#include "core/error.hpp"
 
-#include "color_scheme_editor.hpp"
+#include "gui/backend/glfw_opengl.hpp"
-#include "gui/font_loader.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
-#include "gui/settings_window.hpp"
+#include "gui/platform/font_loader.hpp"
-#include "imgui_helpers.hpp"
+#include "gui/ui_manager.hpp"
-#include "template_editor.hpp"
+#include "gui/views/about_window.hpp"
-#include "about_window.hpp"
+#include "gui/views/color_scheme_editor.hpp"
+#include "gui/views/settings_window.hpp"
+#include "gui/views/template_editor.hpp"
 
-
+int main(int, char **)
-int main(int, char**)
 {
     auto config_path = clrsync::core::get_default_config_path();
     auto conf = std::make_unique<clrsync::core::io::toml_file>(config_path);
@@ -26,7 +27,9 @@ int main(int, char**)
     if (!init_result)
     {
         std::cerr << "Fatal error: " << init_result.error().description() << std::endl;
-        std::cerr << "Hint: Set CLRSYNC_CONFIG_PATH environment variable or ensure config exists at: " << config_path << std::endl;
+        std::cerr
+            << "Hint: Set CLRSYNC_CONFIG_PATH environment variable or ensure config exists at: "
+            << config_path << std::endl;
         return 1;
     }
 
@@ -34,10 +37,20 @@ int main(int, char**)
     static std::string ini_path = (base.parent_path() / "layout.ini").string();
     bool first_time = !std::filesystem::exists(ini_path);
 
-    GLFWwindow* window = init_glfw();
+    printf("GLFW Version: %s\n", glfwGetVersionString());
-    if (!window) return 1;
 
-    printf("GLFV Version: %s\n", glfwGetVersionString());
+    auto backend = clrsync::gui::backend::glfw_opengl_backend();
+    auto window_config = clrsync::gui::backend::window_config();
+    window_config.title = "clrsync";
+    window_config.width = 1280;
+    window_config.height = 720;
+    window_config.transparent_framebuffer = true;
+
+    if (!backend.initialize(window_config))
+    {
+        std::cerr << "Failed to initialize backend." << std::endl;
+        return 1;
+    }
 
     std::cout << "GLFW runtime platform: ";
     switch (glfwGetPlatform()) {
@@ -48,13 +61,23 @@ int main(int, char**)
         default: std::cout << "Unknown\n";
     }
 
+    clrsync::gui::ui_manager ui_manager(&backend);
     
-    init_imgui(window, ini_path);
+    clrsync::gui::ui_config ui_cfg;
+    ui_cfg.ini_path = ini_path;
+    ui_cfg.enable_docking = true;
+    ui_cfg.enable_keyboard_nav = true;
+    
+    if (!ui_manager.initialize(ui_cfg))
+    {
+        std::cerr << "Failed to initialize UI manager." << std::endl;
+        return 1;
+    }
 
     font_loader loader;
 
-    ImFont* font =
+    ImFont *font = loader.load_font(clrsync::core::config::instance().font().c_str(),
-        loader.load_font(clrsync::core::config::instance().font().c_str(), clrsync::core::config::instance().font_size());
+                                    clrsync::core::config::instance().font_size());
 
     if (font)
         ImGui::GetIO().FontDefault = font;
@@ -69,11 +92,12 @@ int main(int, char**)
     templateEditor.apply_current_palette(colorEditor.controller().current_palette());
     settingsWindow.set_palette(colorEditor.controller().current_palette());
 
-    while (!glfwWindowShouldClose(window))
+    while (!backend.should_close())
     {
-        glfwPollEvents();
+        backend.begin_frame();
+        
         loader.push_default_font();
-        begin_frame();
+        ui_manager.begin_frame();
 
         render_menu_bar(&aboutWindow, &settingsWindow);
         setup_main_dockspace(first_time);
@@ -84,8 +108,12 @@ int main(int, char**)
         settingsWindow.render();
 
         loader.pop_font();
-        end_frame(window);
+        
+        ui_manager.end_frame();
+        backend.end_frame();
     }
-    shutdown(window);
+
+    ui_manager.shutdown();
+    backend.shutdown();
     return 0;
 }

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

@@ -1,30 +1,30 @@
 #ifndef CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
 #define CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
 
+#include <imgui.h>
 #include <string>
 #include <vector>
-#include <imgui.h>
 
 class font_loader
 {
-public:
+  public:
     font_loader() = default;
 
-    ImFont* load_font(const char* font_name, float size_px);
+    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:
+  private:
-    std::string find_font_path(const char* font_name);
+    std::string find_font_path(const char *font_name);
 
 #if defined(_WIN32)
-    static std::string find_font_windows(const char* font_name);
+    static std::string find_font_windows(const char *font_name);
 #elif defined(__APPLE__)
-    std::vector<unsigned char> load_font_macos(const char* font_name);
+    std::vector<unsigned char> load_font_macos(const char *font_name);
 #else
-    std::string find_font_linux(const char* font_name);
+    std::string find_font_linux(const char *font_name);
 #endif
 };
 

src/gui/platform/linux/file_browser_linux.cpp

@@ -0,0 +1,133 @@
+#ifdef __linux__
+
+#include "gui/platform/file_browser.hpp"
+#include <gtk/gtk.h>
+#include <filesystem>
+
+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

@@ -1,7 +1,6 @@
-#include "file_browser.hpp"
-#include <filesystem>
-
 #ifdef __APPLE__
+#include "gui/platform/file_browser.hpp"
+#include <filesystem>
 #include <Cocoa/Cocoa.h>
 
 namespace file_dialogs {
@@ -76,5 +75,4 @@ std::string select_folder_dialog(const std::string& title,
 }
 
 }
-
 #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,167 @@
+#ifdef _WIN32
+
+// clang-format off
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <commdlg.h>
+#include <shlobj.h>
+#include <shlwapi.h>
+// clang-format on
+
+#include "gui/platform/file_browser.hpp"
+#include <filesystem>
+
+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);
+                    int size = WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, nullptr, 0,
+                                                   nullptr, nullptr);
+                    std::string result(size - 1, 0);
+                    WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, &result[0], size, nullptr,
+                                        nullptr);
+                    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,170 @@
+#ifdef _WIN32
+#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;
+}
+#endif

src/gui/ui_manager.cpp

@@ -0,0 +1,71 @@
+#include "gui/ui_manager.hpp"
+#include "gui/backend/backend.hpp"
+
+#include <imgui.h>
+
+namespace clrsync::gui
+{
+ui_manager::ui_manager(backend::backend_interface* backend)
+    : m_backend(backend)
+{
+}
+
+ui_manager::~ui_manager()
+{
+    shutdown();
+}
+
+bool ui_manager::initialize(const ui_config& config)
+{
+    IMGUI_CHECKVERSION();
+    m_imgui_context = ImGui::CreateContext();
+    if (!m_imgui_context)
+    {
+        return false;
+    }
+
+    ImGuiIO& io = ImGui::GetIO();
+    
+    if (config.enable_docking)
+        io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    
+    if (config.enable_keyboard_nav)
+        io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+    
+    if (!config.ini_path.empty())
+        io.IniFilename = config.ini_path.c_str();
+
+    ImGui::StyleColorsDark();
+
+    if (!m_backend->init_imgui_backend())
+    {
+        ImGui::DestroyContext(static_cast<ImGuiContext*>(m_imgui_context));
+        m_imgui_context = nullptr;
+        return false;
+    }
+
+    return true;
+}
+
+void ui_manager::shutdown()
+{
+    if (m_imgui_context)
+    {
+        m_backend->shutdown_imgui_backend();
+        ImGui::DestroyContext(static_cast<ImGuiContext*>(m_imgui_context));
+        m_imgui_context = nullptr;
+    }
+}
+
+void ui_manager::begin_frame()
+{
+    m_backend->imgui_new_frame();
+    ImGui::NewFrame();
+}
+
+void ui_manager::end_frame()
+{
+    ImGui::Render();
+    m_backend->imgui_render_draw_data(ImGui::GetDrawData());
+}
+}

src/gui/ui_manager.hpp

@@ -0,0 +1,38 @@
+#ifndef CLRSYNC_UI_MANAGER_HPP
+#define CLRSYNC_UI_MANAGER_HPP
+#include <string>
+
+namespace clrsync::gui::backend
+{
+class backend_interface;
+}
+
+namespace clrsync::gui
+{
+
+struct ui_config
+{
+    std::string ini_path = "";
+    bool enable_docking = true;
+    bool enable_keyboard_nav = true;
+};
+
+class ui_manager
+{
+public:
+    explicit ui_manager(backend::backend_interface *backend);
+    ~ui_manager();
+
+    bool initialize(const ui_config& config = ui_config());
+    void shutdown();
+
+    void begin_frame();
+    void end_frame();
+
+private:
+    backend::backend_interface *m_backend;
+    void *m_imgui_context = nullptr;
+};
+}
+
+#endif

src/gui/views/about_window.cpp

@@ -1,13 +1,13 @@
-#include "about_window.hpp"
+#include "gui/views/about_window.hpp"
-#include "core/version.hpp"
+#include "core/common/version.hpp"
-#include "imgui_helpers.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
 #include "imgui.h"
 
 about_window::about_window()
 {
 }
 
-void about_window::render(const clrsync::core::palette& pal)
+void about_window::render(const clrsync::core::palette &pal)
 {
     if (!m_visible)
         return;

src/gui/views/about_window.hpp

@@ -0,0 +1,33 @@
+#ifndef CLRSYNC_GUI_ABOUT_WINDOW_HPP
+#define CLRSYNC_GUI_ABOUT_WINDOW_HPP
+
+#include "core/palette/palette.hpp"
+
+class about_window
+{
+  public:
+    about_window();
+    void render(const clrsync::core::palette &pal);
+    void render()
+    {
+        render(m_default_palette);
+    }
+    void show()
+    {
+        m_visible = true;
+    }
+    void hide()
+    {
+        m_visible = false;
+    }
+    bool is_visible() const
+    {
+        return m_visible;
+    }
+
+  private:
+    bool m_visible{false};
+    clrsync::core::palette m_default_palette;
+};
+
+#endif // CLRSYNC_GUI_ABOUT_WINDOW_HPP

src/gui/views/color_scheme_editor.cpp

@@ -1,13 +1,12 @@
 #include "color_scheme_editor.hpp"
+#include "gui/controllers/theme_applier.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
 #include "imgui.h"
-#include "imgui_helpers.hpp"
-#include "template_editor.hpp"
 #include "settings_window.hpp"
-#include "theme_applier.hpp"
+#include "template_editor.hpp"
 #include <iostream>
 #include <ranges>
 
-
 color_scheme_editor::color_scheme_editor()
 {
     const auto &current = m_controller.current_palette();
@@ -161,10 +160,8 @@ void color_scheme_editor::render_controls()
 
     ImGui::SameLine();
     auto error = palette_utils::get_color(current, "error");
-    auto error_hover = ImVec4(error.x * 1.1f, error.y * 1.1f, error.z * 1.1f,
+    auto error_hover = ImVec4(error.x * 1.1f, error.y * 1.1f, error.z * 1.1f, error.w);
-                              error.w);
+    auto error_active = ImVec4(error.x * 0.8f, error.y * 0.8f, error.z * 0.8f, error.w);
-    auto error_active = ImVec4(error.x * 0.8f, error.y * 0.8f, error.z * 0.8f,
-                               error.w);
     auto on_error = palette_utils::get_color(current, "on_error");
     ImGui::PushStyleColor(ImGuiCol_Button, error);
     ImGui::PushStyleColor(ImGuiCol_ButtonHovered, error_hover);

src/gui/views/color_scheme_editor.hpp

@@ -0,0 +1,44 @@
+#ifndef CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
+#define CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
+
+#include "gui/controllers/palette_controller.hpp"
+#include "gui/views/color_table_renderer.hpp"
+#include "gui/views/preview_renderer.hpp"
+
+class template_editor;
+class settings_window;
+
+class color_scheme_editor
+{
+  public:
+    color_scheme_editor();
+
+    void render_controls_and_colors();
+    void render_preview();
+    void set_template_editor(template_editor *editor)
+    {
+        m_template_editor = editor;
+    }
+    void set_settings_window(settings_window *window)
+    {
+        m_settings_window = window;
+    }
+    const palette_controller &controller() const
+    {
+        return m_controller;
+    }
+
+  private:
+    void render_controls();
+    void apply_themes();
+    void notify_palette_changed();
+
+    palette_controller m_controller;
+    color_table_renderer m_color_table;
+    preview_renderer m_preview;
+    template_editor *m_template_editor{nullptr};
+    settings_window *m_settings_window{nullptr};
+    bool m_show_delete_confirmation{false};
+};
+
+#endif // CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP

src/gui/views/color_table_renderer.cpp

@@ -1,11 +1,11 @@
-#include "color_table_renderer.hpp"
+#include "gui/views/color_table_renderer.hpp"
-#include "imgui_helpers.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
 #include "imgui.h"
 #include <algorithm>
 #include <cctype>
 #include <vector>
 
-bool color_table_renderer::matches_filter(const std::string& name) const
+bool color_table_renderer::matches_filter(const std::string &name) const
 {
     if (m_filter_text[0] == '\0')
         return true;
@@ -22,9 +22,9 @@ bool color_table_renderer::matches_filter(const std::string& name) const
 }
 
 void color_table_renderer::render_color_row(const std::string &name,
-                                            const clrsync::core::palette& current,
+                                            const clrsync::core::palette &current,
-                                            palette_controller& controller,
+                                            palette_controller &controller,
-                                            const OnColorChangedCallback& on_changed)
+                                            const OnColorChangedCallback &on_changed)
 {
     if (!matches_filter(name))
         return;
@@ -101,9 +101,9 @@ void color_table_renderer::render_color_row(const std::string &name,
     ImGui::PopID();
 }
 
-void color_table_renderer::render(const clrsync::core::palette& current,
+void color_table_renderer::render(const clrsync::core::palette &current,
-                                  palette_controller& controller,
+                                  palette_controller &controller,
-                                  const OnColorChangedCallback& on_changed)
+                                  const OnColorChangedCallback &on_changed)
 {
     if (current.colors().empty())
     {
@@ -138,7 +138,8 @@ void color_table_renderer::render(const clrsync::core::palette& current,
     ImGui::Separator();
     ImGui::Spacing();
 
-    auto draw_table = [&](const char *title, const char* id, const std::vector<const char *> &keys) {
+    auto draw_table = [&](const char *title, const char *id,
+                          const std::vector<const char *> &keys) {
         bool has_matches = false;
         for (auto *k : keys)
         {
@@ -153,13 +154,15 @@ void color_table_renderer::render(const clrsync::core::palette& current,
             return;
 
         ImGui::PushStyleColor(ImGuiCol_Text, palette_utils::get_color(current, "accent"));
-        bool header_open = ImGui::TreeNodeEx(title, ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_SpanAvailWidth);
+        bool header_open = ImGui::TreeNodeEx(title, ImGuiTreeNodeFlags_DefaultOpen |
+                                                        ImGuiTreeNodeFlags_SpanAvailWidth);
         ImGui::PopStyleColor();
 
         if (header_open)
         {
             if (ImGui::BeginTable(id, 3,
-                ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp))
+                                  ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
+                                      ImGuiTableFlags_SizingStretchProp))
             {
                 ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, 160.0f);
                 ImGui::TableSetupColumn("HEX", ImGuiTableColumnFlags_WidthFixed, 95.0f);
@@ -177,23 +180,23 @@ void color_table_renderer::render(const clrsync::core::palette& current,
         ImGui::Spacing();
     };
 
-    draw_table("General UI", "##general_ui", {"background", "on_background", "surface", "on_surface",
+    draw_table("General UI", "##general_ui",
-                              "surface_variant", "on_surface_variant", "foreground",
+               {"background", "on_background", "surface", "on_surface", "surface_variant",
-                              "cursor", "accent"});
+                "on_surface_variant", "foreground", "cursor", "accent"});
 
     draw_table("Borders", "##borders", {"border_focused", "border"});
 
-    draw_table("Semantic Colors", "##semantic", {"success", "info", "warning", "error",
+    draw_table(
-                                   "on_success", "on_info", "on_warning", "on_error"});
+        "Semantic Colors", "##semantic",
+        {"success", "info", "warning", "error", "on_success", "on_info", "on_warning", "on_error"});
 
-    draw_table("Editor", "##editor", {"editor_background", "editor_command", "editor_comment",
+    draw_table("Editor", "##editor",
-                          "editor_disabled", "editor_emphasis", "editor_error",
+               {"editor_background", "editor_command", "editor_comment", "editor_disabled",
-                          "editor_inactive", "editor_line_number", "editor_link",
+                "editor_emphasis", "editor_error", "editor_inactive", "editor_line_number",
-                          "editor_main", "editor_selected", "editor_selection_inactive",
+                "editor_link", "editor_main", "editor_selected", "editor_selection_inactive",
                 "editor_string", "editor_success", "editor_warning"});
 
-    draw_table("Terminal (Base16)", "##terminal", {"base00", "base01", "base02", "base03",
+    draw_table("Terminal (Base16)", "##terminal",
-                                     "base04", "base05", "base06", "base07",
+               {"base00", "base01", "base02", "base03", "base04", "base05", "base06", "base07",
-                                     "base08", "base09", "base0A", "base0B",
+                "base08", "base09", "base0A", "base0B", "base0C", "base0D", "base0E", "base0F"});
-                                     "base0C", "base0D", "base0E", "base0F"});
 }

src/gui/views/color_table_renderer.hpp

@@ -0,0 +1,27 @@
+#ifndef CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP
+#define CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP
+
+#include "core/palette/palette.hpp"
+#include "gui/controllers/palette_controller.hpp"
+#include <functional>
+#include <string>
+
+class color_table_renderer
+{
+  public:
+    using OnColorChangedCallback = std::function<void()>;
+
+    void render(const clrsync::core::palette &palette, palette_controller &controller,
+                const OnColorChangedCallback &on_changed);
+
+  private:
+    void render_color_row(const std::string &name, const clrsync::core::palette &palette,
+                          palette_controller &controller, const OnColorChangedCallback &on_changed);
+
+    bool matches_filter(const std::string &name) const;
+
+    char m_filter_text[128] = {0};
+    bool m_show_only_modified{false};
+};
+
+#endif // CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP

src/gui/views/preview_renderer.cpp

@@ -1,6 +1,6 @@
-#include "preview_renderer.hpp"
+#include "gui/views/preview_renderer.hpp"
-#include "theme_applier.hpp"
+#include "gui/controllers/theme_applier.hpp"
-#include "imgui_helpers.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
 #include "imgui.h"
 #include <algorithm>
 #include <array>
@@ -74,15 +74,11 @@ int main()
 
 static ImVec4 hex_to_imvec4(uint32_t hex)
 {
-    return {
+    return {((hex >> 24) & 0xFF) / 255.0f, ((hex >> 16) & 0xFF) / 255.0f,
-        ((hex >> 24) & 0xFF) / 255.0f,
+            ((hex >> 8) & 0xFF) / 255.0f, (hex & 0xFF) / 255.0f};
-        ((hex >> 16) & 0xFF) / 255.0f,
-        ((hex >> 8) & 0xFF) / 255.0f,
-        (hex & 0xFF) / 255.0f
-    };
 }
 
-void preview_renderer::apply_palette(const clrsync::core::palette& palette)
+void preview_renderer::apply_palette(const clrsync::core::palette &palette)
 {
     theme_applier::apply_to_editor(m_editor, palette);
 }
@@ -98,7 +94,7 @@ void preview_renderer::render_code_preview()
     m_editor.Render("##CodeEditor", ImVec2(0, code_preview_height), true);
 }
 
-void preview_renderer::render_terminal_preview(const clrsync::core::palette& current)
+void preview_renderer::render_terminal_preview(const clrsync::core::palette &current)
 {
     auto get_color = [&](const std::string &key) -> ImVec4 {
         const auto &col = current.get_color(key);
@@ -207,7 +203,7 @@ void preview_renderer::render_terminal_preview(const clrsync::core::palette& cur
     const float box_size = 20.0f;
     const float spacing = 4.0f;
     ImVec2 start_pos = ImGui::GetCursorScreenPos();
-    ImDrawList* draw_list = ImGui::GetWindowDrawList();
+    ImDrawList *draw_list = ImGui::GetWindowDrawList();
 
     std::array<ImVec4, 8> normal_colors = {black, red, green, yellow, blue, magenta, cyan, white};
     for (size_t i = 0; i < 8; i++)
@@ -218,11 +214,13 @@ void preview_renderer::render_terminal_preview(const clrsync::core::palette& cur
         draw_list->AddRect(p0, p1, ImGui::ColorConvertFloat4ToU32(border_col));
     }
 
-    std::array<ImVec4, 8> bright_colors = {bright_black, bright_red, bright_green, bright_yellow, 
+    std::array<ImVec4, 8> bright_colors = {bright_black,  bright_red,  bright_green,
-                                            bright_blue, bright_magenta, bright_cyan, bright_white};
+                                           bright_yellow, bright_blue, bright_magenta,
+                                           bright_cyan,   bright_white};
     for (size_t i = 0; i < 8; i++)
     {
-        ImVec2 p0 = ImVec2(start_pos.x + i * (box_size + spacing), start_pos.y + box_size + spacing);
+        ImVec2 p0 =
+            ImVec2(start_pos.x + i * (box_size + spacing), start_pos.y + box_size + spacing);
         ImVec2 p1 = ImVec2(p0.x + box_size, p0.y + box_size);
         draw_list->AddRectFilled(p0, p1, ImGui::ColorConvertFloat4ToU32(bright_colors[i]));
         draw_list->AddRect(p0, p1, ImGui::ColorConvertFloat4ToU32(border_col));
@@ -234,7 +232,7 @@ void preview_renderer::render_terminal_preview(const clrsync::core::palette& cur
     ImGui::EndChild();
 }
 
-void preview_renderer::render(const clrsync::core::palette& current)
+void preview_renderer::render(const clrsync::core::palette &current)
 {
     if (current.colors().empty())
     {

src/gui/views/preview_renderer.hpp

@@ -1,20 +1,20 @@
 #ifndef CLRSYNC_GUI_PREVIEW_RENDERER_HPP
 #define CLRSYNC_GUI_PREVIEW_RENDERER_HPP
 
-#include "core/palette/palette.hpp"
 #include "color_text_edit/TextEditor.h"
+#include "core/palette/palette.hpp"
 
 class preview_renderer
 {
-public:
+  public:
     preview_renderer();
 
-    void render(const clrsync::core::palette& palette);
+    void render(const clrsync::core::palette &palette);
-    void apply_palette(const clrsync::core::palette& palette);
+    void apply_palette(const clrsync::core::palette &palette);
 
-private:
+  private:
     void render_code_preview();
-    void render_terminal_preview(const clrsync::core::palette& palette);
+    void render_terminal_preview(const clrsync::core::palette &palette);
 
     TextEditor m_editor;
 };

src/gui/views/settings_window.cpp

@@ -1,9 +1,9 @@
-#include "settings_window.hpp"
+#include "gui/views/settings_window.hpp"
+#include "core/common/error.hpp"
 #include "core/config/config.hpp"
-#include "core/error.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
-#include "gui/font_loader.hpp"
+#include "gui/platform/file_browser.hpp"
-#include "gui/imgui_helpers.hpp"
+#include "gui/platform/font_loader.hpp"
-#include "gui/file_browser.hpp"
 #include "imgui.h"
 #include <cstring>
 
@@ -26,7 +26,8 @@ void settings_window::render()
         return;
 
     ImGui::SetNextWindowSize(ImVec2(700, 500), ImGuiCond_FirstUseEver);
-    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_FirstUseEver, ImVec2(0.5f, 0.5f));
+    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_FirstUseEver,
+                            ImVec2(0.5f, 0.5f));
 
     ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoCollapse;
     if (ImGui::Begin("Settings", &m_visible, window_flags))
@@ -58,7 +59,7 @@ void settings_window::render()
 
 void settings_window::load_settings()
 {
-    auto& cfg = clrsync::core::config::instance();
+    auto &cfg = clrsync::core::config::instance();
 
     std::string default_theme = cfg.default_theme();
     strncpy(m_default_theme, default_theme.c_str(), sizeof(m_default_theme) - 1);
@@ -90,7 +91,7 @@ void settings_window::load_settings()
 
 void settings_window::apply_settings()
 {
-    auto& cfg = clrsync::core::config::instance();
+    auto &cfg = clrsync::core::config::instance();
 
     if (strlen(m_default_theme) == 0)
     {
@@ -184,8 +185,10 @@ void settings_window::render_general_tab()
     ImGui::SameLine();
     if (ImGui::Button("Browse"))
     {
-        std::string selected_path = file_dialogs::select_folder_dialog("Select Palettes Directory", m_palettes_path);
+        std::string selected_path =
-        if (!selected_path.empty()) {
+            file_dialogs::select_folder_dialog("Select Palettes Directory", m_palettes_path);
+        if (!selected_path.empty())
+        {
             strncpy(m_palettes_path, selected_path.c_str(), sizeof(m_palettes_path) - 1);
             m_palettes_path[sizeof(m_palettes_path) - 1] = '\0';
             m_settings_changed = true;
@@ -259,7 +262,8 @@ void settings_window::render_status_messages()
         ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 4.0f);
         ImGui::PushStyleVar(ImGuiStyleVar_ChildBorderSize, 1.0f);
 
-        if (ImGui::BeginChild("##error_box", ImVec2(0, 0), ImGuiChildFlags_AutoResizeY | ImGuiChildFlags_Borders))
+        if (ImGui::BeginChild("##error_box", ImVec2(0, 0),
+                              ImGuiChildFlags_AutoResizeY | ImGuiChildFlags_Borders))
         {
             ImGui::PushStyleColor(ImGuiCol_Text, error_text_color);
             ImGui::TextWrapped("Error: %s", m_error_message.c_str());
@@ -267,8 +271,12 @@ void settings_window::render_status_messages()
 
             ImGui::Spacing();
 
-            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(error_bg_color.x * 0.8f, error_bg_color.y * 0.8f, error_bg_color.z * 0.8f, error_bg_color.w));
+            ImGui::PushStyleColor(ImGuiCol_Button,
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(error_bg_color.x * 0.6f, error_bg_color.y * 0.6f, error_bg_color.z * 0.6f, error_bg_color.w));
+                                  ImVec4(error_bg_color.x * 0.8f, error_bg_color.y * 0.8f,
+                                         error_bg_color.z * 0.8f, error_bg_color.w));
+            ImGui::PushStyleColor(ImGuiCol_ButtonHovered,
+                                  ImVec4(error_bg_color.x * 0.6f, error_bg_color.y * 0.6f,
+                                         error_bg_color.z * 0.6f, error_bg_color.w));
             ImGui::PushStyleColor(ImGuiCol_Text, error_text_color);
 
             if (ImGui::Button("Dismiss##error"))
@@ -347,7 +355,7 @@ void settings_window::render_action_buttons()
     }
 }
 
-void settings_window::show_help_marker(const char* desc)
+void settings_window::show_help_marker(const char *desc)
 {
     ImGui::TextDisabled("(?)");
     if (ImGui::BeginItemTooltip())

src/gui/views/settings_window.hpp

@@ -7,14 +7,23 @@
 
 class settings_window
 {
-public:
+  public:
     settings_window();
     void render();
-    void show() { m_visible = true; }
+    void show()
-    void hide() { m_visible = false; }
+    {
-    bool is_visible() const { return m_visible; }
+        m_visible = true;
+    }
+    void hide()
+    {
+        m_visible = false;
+    }
+    bool is_visible() const
+    {
+        return m_visible;
+    }
 
-private:
+  private:
     void load_settings();
     void save_settings();
     void apply_settings();
@@ -22,11 +31,12 @@ private:
     void render_appearance_tab();
     void render_status_messages();
     void render_action_buttons();
-    void show_help_marker(const char* desc);
+    void show_help_marker(const char *desc);
     void reset_to_defaults();
 
-public:
+  public:
-    void set_palette(const clrsync::core::palette& palette) { 
+    void set_palette(const clrsync::core::palette &palette)
+    {
         m_current_palette = palette;
     }
 

src/gui/views/template_editor.cpp

@@ -1,24 +1,21 @@
 #include "template_editor.hpp"
+#include "core/common/utils.hpp"
 #include "core/config/config.hpp"
-#include "core/theme/theme_template.hpp"
 #include "core/palette/color_keys.hpp"
-#include "core/utils.hpp"
+#include "core/theme/theme_template.hpp"
-#include "imgui_helpers.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
-#include "file_browser.hpp"
+#include "gui/platform/file_browser.hpp"
 #include "imgui.h"
 #include <algorithm>
 #include <filesystem>
 #include <fstream>
 #include <ranges>
 
-namespace {
+namespace
-    const std::vector<std::string> COLOR_FORMATS = {
+{
-        "hex", "hex_stripped", "hexa", "hexa_stripped",
+const std::vector<std::string> COLOR_FORMATS = {
-        "r", "g", "b", "a",
+    "hex", "hex_stripped", "hexa", "hexa_stripped", "r", "g", "b", "a", "rgb", "rgba", "h", "s",
-        "rgb", "rgba",
+    "l",   "hsl",          "hsla"};
-        "h", "s", "l",
-        "hsl", "hsla"
-    };
 }
 
 template_editor::template_editor() : m_template_name("new_template")
@@ -108,7 +105,8 @@ void template_editor::apply_current_palette(const clrsync::core::palette &pal)
     m_autocomplete_selected_color = palette_utils::get_color(pal, "accent", "surface_variant");
     m_autocomplete_text_color = palette_utils::get_color(pal, "on_surface", "foreground");
     m_autocomplete_selected_text_color = palette_utils::get_color(pal, "on_surface", "foreground");
-    m_autocomplete_dim_text_color = palette_utils::get_color(pal, "on_surface_variant", "editor_inactive");
+    m_autocomplete_dim_text_color =
+        palette_utils::get_color(pal, "on_surface_variant", "editor_inactive");
 }
 
 void template_editor::update_autocomplete_suggestions()
@@ -148,8 +146,7 @@ void template_editor::update_autocomplete_suggestions()
     {
         bool should_reset_dismissal = false;
 
-        if (cursor.mLine != m_dismiss_position.mLine ||
+        if (cursor.mLine != m_dismiss_position.mLine || brace_pos != m_dismiss_brace_pos ||
-            brace_pos != m_dismiss_brace_pos ||
             abs(cursor.mColumn - m_dismiss_position.mColumn) > 3)
         {
             should_reset_dismissal = true;
@@ -190,8 +187,7 @@ void template_editor::update_autocomplete_suggestions()
         {
             for (const auto &fmt : COLOR_FORMATS)
             {
-                if (format_prefix.empty() || 
+                if (format_prefix.empty() || fmt.find(format_prefix) == 0 ||
-                    fmt.find(format_prefix) == 0 ||
                     fmt.find(format_prefix) != std::string::npos)
                 {
                     m_autocomplete_suggestions.push_back(color_key + "." + fmt);
@@ -204,8 +200,7 @@ void template_editor::update_autocomplete_suggestions()
         for (size_t i = 0; i < clrsync::core::NUM_COLOR_KEYS; ++i)
         {
             std::string key = clrsync::core::COLOR_KEYS[i];
-            if (m_autocomplete_prefix.empty() || 
+            if (m_autocomplete_prefix.empty() || key.find(m_autocomplete_prefix) == 0 ||
-                key.find(m_autocomplete_prefix) == 0 ||
                 key.find(m_autocomplete_prefix) != std::string::npos)
             {
                 m_autocomplete_suggestions.push_back(key);
@@ -229,7 +224,7 @@ void template_editor::update_autocomplete_suggestions()
     }
 }
 
-void template_editor::render_autocomplete(const ImVec2& editor_pos)
+void template_editor::render_autocomplete(const ImVec2 &editor_pos)
 {
     if (!m_show_autocomplete || m_autocomplete_suggestions.empty())
         return;
@@ -241,7 +236,8 @@ void template_editor::render_autocomplete(const ImVec2& editor_pos)
     const float line_number_width = 50.0f;
 
     ImVec2 popup_pos;
-    popup_pos.x = editor_pos.x + line_number_width + (m_autocomplete_start_pos.mColumn * char_width);
+    popup_pos.x =
+        editor_pos.x + line_number_width + (m_autocomplete_start_pos.mColumn * char_width);
     popup_pos.y = editor_pos.y + ((cursor.mLine + 1) * line_height);
 
     ImGui::SetNextWindowPos(popup_pos, ImGuiCond_Always);
@@ -249,7 +245,8 @@ void template_editor::render_autocomplete(const ImVec2& editor_pos)
 
     ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
                              ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
-                             ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_AlwaysAutoResize;
+                             ImGuiWindowFlags_NoFocusOnAppearing |
+                             ImGuiWindowFlags_AlwaysAutoResize;
 
     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(6, 6));
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
@@ -295,8 +292,8 @@ void template_editor::render_autocomplete(const ImVec2& editor_pos)
 
             std::string display_text = "  " + suggestion;
 
-            if (ImGui::Selectable(display_text.c_str(), is_selected, 
+            if (ImGui::Selectable(display_text.c_str(), is_selected, ImGuiSelectableFlags_None,
-                                  ImGuiSelectableFlags_None, ImVec2(0, 0)))
+                                  ImVec2(0, 0)))
             {
                 auto start = m_autocomplete_start_pos;
                 auto end = m_editor.GetCursorPosition();
@@ -362,8 +359,7 @@ void template_editor::render()
     }
 
     palette_utils::render_delete_confirmation_popup(
-        "Delete Template?", m_template_name, "template", m_current_palette,
+        "Delete Template?", m_template_name, "template", m_current_palette, [this]() {
-        [this]() {
             bool success = m_template_controller.remove_template(m_template_name);
             if (success)
             {
@@ -408,10 +404,8 @@ void template_editor::render_controls()
     {
         ImGui::SameLine();
         auto error = palette_utils::get_color(m_current_palette, "error");
-        auto error_hover = ImVec4(error.x * 1.1f, error.y * 1.1f, error.z * 1.1f,
+        auto error_hover = ImVec4(error.x * 1.1f, error.y * 1.1f, error.z * 1.1f, error.w);
-                                error.w);
+        auto error_active = ImVec4(error.x * 0.8f, error.y * 0.8f, error.z * 0.8f, error.w);
-        auto error_active = ImVec4(error.x * 0.8f, error.y * 0.8f, error.z * 0.8f,
-                                error.w);
         auto on_error = palette_utils::get_color(m_current_palette, "on_error");
         ImGui::PushStyleColor(ImGuiCol_Button, error);
         ImGui::PushStyleColor(ImGuiCol_ButtonHovered, error_hover);
@@ -433,18 +427,24 @@ void template_editor::render_controls()
     if (m_enabled)
     {
         ImVec4 success_color = palette_utils::get_color(m_current_palette, "success", "accent");
-        ImVec4 success_on_color = palette_utils::get_color(m_current_palette, "on_success", "on_surface");
+        ImVec4 success_on_color =
-        ImVec4 success_hover = ImVec4(success_color.x * 1.2f, success_color.y * 1.2f, success_color.z * 1.2f, 0.6f);
+            palette_utils::get_color(m_current_palette, "on_success", "on_surface");
-        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(success_color.x, success_color.y, success_color.z, 0.5f));
+        ImVec4 success_hover =
+            ImVec4(success_color.x * 1.2f, success_color.y * 1.2f, success_color.z * 1.2f, 0.6f);
+        ImGui::PushStyleColor(ImGuiCol_FrameBg,
+                              ImVec4(success_color.x, success_color.y, success_color.z, 0.5f));
         ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, success_hover);
         ImGui::PushStyleColor(ImGuiCol_CheckMark, success_on_color);
     }
     else
     {
         ImVec4 error_color = palette_utils::get_color(m_current_palette, "error", "accent");
-        ImVec4 error_on_color = palette_utils::get_color(m_current_palette, "on_error", "on_surface");
+        ImVec4 error_on_color =
-        ImVec4 error_hover = ImVec4(error_color.x * 1.2f, error_color.y * 1.2f, error_color.z * 1.2f, 0.6f);
+            palette_utils::get_color(m_current_palette, "on_error", "on_surface");
-        ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(error_color.x, error_color.y, error_color.z, 0.5f));
+        ImVec4 error_hover =
+            ImVec4(error_color.x * 1.2f, error_color.y * 1.2f, error_color.z * 1.2f, 0.6f);
+        ImGui::PushStyleColor(ImGuiCol_FrameBg,
+                              ImVec4(error_color.x, error_color.y, error_color.z, 0.5f));
         ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, error_hover);
         ImGui::PushStyleColor(ImGuiCol_CheckMark, error_on_color);
     }
@@ -486,8 +486,8 @@ void template_editor::render_controls()
     ImGui::SetNextItemWidth(-120.0f);
     char input_path_buf[512] = {0};
     snprintf(input_path_buf, sizeof(input_path_buf), "%s", m_input_path.c_str());
-    if (ImGui::InputTextWithHint("##input_path", "Path to template file...", 
+    if (ImGui::InputTextWithHint("##input_path", "Path to template file...", input_path_buf,
-                                  input_path_buf, sizeof(input_path_buf)))
+                                 sizeof(input_path_buf)))
     {
         m_input_path = input_path_buf;
         if (!m_input_path.empty())
@@ -502,10 +502,13 @@ void template_editor::render_controls()
     ImGui::SameLine();
     if (ImGui::Button("Browse##input"))
     {
-        std::string selected_path = file_dialogs::open_file_dialog("Select Template File", m_input_path);
+        std::string selected_path =
-        if (!selected_path.empty()) {
+            file_dialogs::open_file_dialog("Select Template File", m_input_path);
+        if (!selected_path.empty())
+        {
             m_input_path = selected_path;
-            if (m_is_editing_existing) {
+            if (m_is_editing_existing)
+            {
                 m_template_controller.set_template_input_path(m_template_name, m_input_path);
             }
             m_validation_error = "";
@@ -520,8 +523,8 @@ void template_editor::render_controls()
     ImGui::SetNextItemWidth(-120.0f);
     char path_buf[512] = {0};
     snprintf(path_buf, sizeof(path_buf), "%s", m_output_path.c_str());
-    if (ImGui::InputTextWithHint("##output_path", "Path for generated config...", 
+    if (ImGui::InputTextWithHint("##output_path", "Path for generated config...", path_buf,
-                                 path_buf, sizeof(path_buf)))
+                                 sizeof(path_buf)))
     {
         m_output_path = path_buf;
         if (!m_output_path.empty())
@@ -536,10 +539,13 @@ void template_editor::render_controls()
     ImGui::SameLine();
     if (ImGui::Button("Browse##output"))
     {
-        std::string selected_path = file_dialogs::save_file_dialog("Select Output File", m_output_path);
+        std::string selected_path =
-        if (!selected_path.empty()) {
+            file_dialogs::save_file_dialog("Select Output File", m_output_path);
+        if (!selected_path.empty())
+        {
             m_output_path = selected_path;
-            if (m_is_editing_existing) {
+            if (m_is_editing_existing)
+            {
                 m_template_controller.set_template_output_path(m_template_name, m_output_path);
             }
             m_validation_error = "";
@@ -554,8 +560,8 @@ void template_editor::render_controls()
     ImGui::SetNextItemWidth(-FLT_MIN);
     char reload_buf[512] = {0};
     snprintf(reload_buf, sizeof(reload_buf), "%s", m_reload_command.c_str());
-    if (ImGui::InputTextWithHint("##reload_cmd", "Command to reload app (optional)...",
+    if (ImGui::InputTextWithHint("##reload_cmd", "Command to reload app (optional)...", reload_buf,
-                                 reload_buf, sizeof(reload_buf)))
+                                 sizeof(reload_buf)))
     {
         m_reload_command = reload_buf;
         if (m_is_editing_existing)
@@ -708,7 +714,8 @@ void template_editor::render_template_list()
 
         if (!tmpl.enabled())
         {
-            ImVec4 disabled_color = palette_utils::get_color(m_current_palette, "on_surface_variant", "editor_inactive");
+            ImVec4 disabled_color = palette_utils::get_color(
+                m_current_palette, "on_surface_variant", "editor_inactive");
             ImGui::PushStyleColor(ImGuiCol_Text, disabled_color);
         }
 
@@ -838,7 +845,7 @@ void template_editor::save_template()
         {
             std::filesystem::create_directories(parent_dir);
         }
-        catch (const std::exception& e)
+        catch (const std::exception &e)
         {
             m_validation_error = "Error: Could not create directory for input path";
             return;

src/gui/views/template_editor.hpp

@@ -1,25 +1,25 @@
 #ifndef CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
 #define CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
 
-#include "template_controller.hpp"
-#include <core/palette/palette.hpp>
 #include "color_text_edit/TextEditor.h"
+#include "core/palette/palette.hpp"
+#include "gui/controllers/template_controller.hpp"
 #include "imgui.h"
 #include <string>
 #include <vector>
 
 class template_editor
 {
-public:
+  public:
     template_editor();
     void render();
-    void apply_current_palette(const clrsync::core::palette& pal);
+    void apply_current_palette(const clrsync::core::palette &pal);
 
-private:
+  private:
     void render_controls();
     void render_editor();
     void render_template_list();
-    void render_autocomplete(const ImVec2& editor_pos);
+    void render_autocomplete(const ImVec2 &editor_pos);
     void update_autocomplete_suggestions();
 
     void save_template();