AppPreferences.cpp

Go to the documentation of this file.

#include "Utils/AppPreferences.h"
#include "Utils/Logger.h"
#include "Utils/ResourcePath.h"
#include <wx/colour.h>
#include <wx/file.h>
#include <wx/fileconf.h>
#include <wx/filename.h>
#include <wx/tokenzr.h>
 
namespace EmberForge {
 
AppPreferences::AppPreferences() {
    // Defaults are set in the struct definitions
}
 
void AppPreferences::ResetToDefaults() {
    LOG_INFO("AppPreferences", "Resetting preferences to defaults");
 
    windowSettings_ = WindowSettings{};
    mainPanelSettings_ = MainPanelSettings{};
    behaviorTreeViewSettings_ = BehaviorTreeViewSettings{};
    bottomPanelSettings_ = BottomPanelSettings{};
    sidePanelSettings_ = SidePanelSettings{};
    parserSettings_ = ParserSettings{};
    performanceSettings_ = PerformanceSettings{};
}
 
EmberCore::String AppPreferences::GetDefaultConfigPath() {
    return ResourcePath::Get("config/app_preferences.conf").ToStdString();
}
 
bool AppPreferences::LoadFromFile(const EmberCore::String &filename) {
    LOG_INFO("AppPreferences", "Loading preferences from: " + filename);
 
    if (!wxFile::Exists(filename)) {
        LOG_WARNING("AppPreferences", "Preferences file does not exist: " + filename);
        return false;
    }
 
    try {
        wxFileConfig config(wxEmptyString, wxEmptyString, filename, wxEmptyString,
                            wxCONFIG_USE_LOCAL_FILE | wxCONFIG_USE_RELATIVE_PATH);
 
        // Load window settings
        config.SetPath("/Window");
        windowSettings_.windowX = config.Read("WindowX", -1L);
        windowSettings_.windowY = config.Read("WindowY", -1L);
        windowSettings_.windowWidth = config.Read("WindowWidth", 1280L);
        windowSettings_.windowHeight = config.Read("WindowHeight", 720L);
 
        wxString startupModeStr = config.Read("StartupMode", "Normal");
        windowSettings_.startupMode = StringToStartupMode(startupModeStr.ToStdString());
 
        windowSettings_.maximizeHotkey = config.Read("MaximizeHotkey", "F11");
 
        // File menu hotkeys
        windowSettings_.newProjectHotkey = config.Read("NewProjectHotkey", "Ctrl+Shift+N");
        windowSettings_.openProjectHotkey = config.Read("OpenProjectHotkey", "Ctrl+Shift+O");
        windowSettings_.openFileHotkey = config.Read("OpenFileHotkey", "Ctrl+O");
        windowSettings_.saveHotkey = config.Read("SaveHotkey", "Ctrl+S");
        windowSettings_.saveAsHotkey = config.Read("SaveAsHotkey", "Ctrl+Shift+S");
 
        // View menu hotkeys
        windowSettings_.resetUIHotkey = config.Read("ResetUIHotkey", "Ctrl+Shift+R");
 
        // Settings menu hotkeys
        windowSettings_.preferencesHotkey = config.Read("PreferencesHotkey", "Ctrl+,");
        windowSettings_.parserConfigHotkey = config.Read("ParserConfigHotkey", "Ctrl+Shift+P");
 
        wxString themeStr = config.Read("Theme", "Dark");
        windowSettings_.theme = StringToThemeMode(themeStr.ToStdString());
 
        long r = config.Read("AccentColorR", 100L);
        long g = config.Read("AccentColorG", 149L);
        long b = config.Read("AccentColorB", 237L);
        windowSettings_.accentColor = EmberCore::Color(r, g, b);
 
        // Window appearance and behavior
        windowSettings_.showStatusBar = config.ReadBool("ShowStatusBar", true);
        windowSettings_.showPanelCaptions = config.ReadBool("ShowPanelCaptions", false);
        windowSettings_.alwaysOnTop = config.ReadBool("AlwaysOnTop", false);
 
        // Window constraints (percentage of screen)
        windowSettings_.minWindowWidthPct = config.Read("MinWindowWidthPct", 42L);
        windowSettings_.minWindowHeightPct = config.Read("MinWindowHeightPct", 56L);
        windowSettings_.maxWindowWidthPct = config.Read("MaxWindowWidthPct", -1L);
        windowSettings_.maxWindowHeightPct = config.Read("MaxWindowHeightPct", -1L);
        windowSettings_.enforceAspectRatio = config.ReadBool("EnforceAspectRatio", false);
        windowSettings_.aspectRatio = config.ReadDouble("AspectRatio", 16.0 / 9.0);
 
        // Load main panel settings
        config.SetPath("/MainPanel");
        windowSettings_.windowWidth = config.Read("WindowWidth", 1280L);
        mainPanelSettings_.defaultZoomLevel = config.ReadDouble("DefaultZoomLevel", 1.0);
        mainPanelSettings_.showGrid = config.ReadBool("ShowGrid", true);
        mainPanelSettings_.gridSize = config.Read("GridSize", 20L);
 
        r = config.Read("GridBackgroundR", 45L);
        g = config.Read("GridBackgroundG", 45L);
        b = config.Read("GridBackgroundB", 45L);
        mainPanelSettings_.gridBackgroundColor = EmberCore::Color(r, g, b);
 
        r = config.Read("GridLineR", 54L);
        g = config.Read("GridLineG", 54L);
        b = config.Read("GridLineB", 54L);
        mainPanelSettings_.gridLineColor = EmberCore::Color(r, g, b);
 
        mainPanelSettings_.snapToGrid = config.ReadBool("SnapToGrid", false);
 
        r = config.Read("CanvasBackgroundR", 50L);
        g = config.Read("CanvasBackgroundG", 50L);
        b = config.Read("CanvasBackgroundB", 50L);
        mainPanelSettings_.canvasBackgroundColor = EmberCore::Color(r, g, b);
 
        r = config.Read("ConnectionLineR", 255L);
        g = config.Read("ConnectionLineG", 255L);
        b = config.Read("ConnectionLineB", 255L);
        mainPanelSettings_.connectionLineColor = EmberCore::Color(r, g, b);
 
        mainPanelSettings_.highlightPathToSelected = config.ReadBool("HighlightPathToSelected", true);
 
        r = config.Read("PathHighlightR", 144L);
        g = config.Read("PathHighlightG", 238L);
        b = config.Read("PathHighlightB", 144L);
        mainPanelSettings_.pathHighlightColor = EmberCore::Color(r, g, b);
 
        r = config.Read("IdleNodeBgR", 75L);
        g = config.Read("IdleNodeBgG", 75L);
        b = config.Read("IdleNodeBgB", 75L);
        mainPanelSettings_.idleNodeBgColor = EmberCore::Color(r, g, b);
 
        r = config.Read("IdleNodeBorderR", 120L);
        g = config.Read("IdleNodeBorderG", 120L);
        b = config.Read("IdleNodeBorderB", 120L);
        mainPanelSettings_.idleNodeBorderColor = EmberCore::Color(r, g, b);
 
        r = config.Read("IdleNodeTextR", 180L);
        g = config.Read("IdleNodeTextG", 180L);
        b = config.Read("IdleNodeTextB", 180L);
        mainPanelSettings_.idleNodeTextColor = EmberCore::Color(r, g, b);
 
        mainPanelSettings_.selectedNodeBgTint = static_cast<float>(config.Read("SelectedNodeBgTint", -33L)) / 100.0f;
        mainPanelSettings_.hoveredNodeBgTint = static_cast<float>(config.Read("HoveredNodeBgTint", -13L)) / 100.0f;
 
        r = config.Read("SelectedNodeR", 48L);
        g = config.Read("SelectedNodeG", 92L);
        b = config.Read("SelectedNodeB", 222L);
        mainPanelSettings_.selectedNodeColor = EmberCore::Color(r, g, b);
 
        r = config.Read("HoveredNodeR", 144L);
        g = config.Read("HoveredNodeG", 238L);
        b = config.Read("HoveredNodeB", 144L);
        mainPanelSettings_.hoveredNodeColor = EmberCore::Color(r, g, b);
 
        r = config.Read("SelectedNodeTextR", 255L);
        g = config.Read("SelectedNodeTextG", 255L);
        b = config.Read("SelectedNodeTextB", 255L);
        mainPanelSettings_.selectedNodeTextColor = EmberCore::Color(r, g, b);
 
        r = config.Read("HoveredNodeTextR", 255L);
        g = config.Read("HoveredNodeTextG", 255L);
        b = config.Read("HoveredNodeTextB", 255L);
        mainPanelSettings_.hoveredNodeTextColor = EmberCore::Color(r, g, b);
 
        r = config.Read("SelectedNodeInfoR", 200L);
        g = config.Read("SelectedNodeInfoG", 200L);
        b = config.Read("SelectedNodeInfoB", 200L);
        mainPanelSettings_.selectedNodeInfoColor = EmberCore::Color(r, g, b);
 
        r = config.Read("HoveredNodeInfoR", 200L);
        g = config.Read("HoveredNodeInfoG", 200L);
        b = config.Read("HoveredNodeInfoB", 200L);
        mainPanelSettings_.hoveredNodeInfoColor = EmberCore::Color(r, g, b);
 
        mainPanelSettings_.maxScenes = config.Read("MaxScenes", 10L);
 
        wxString closeConfirmStr = config.Read("CloseConfirmation", "AskIfUnsaved");
        mainPanelSettings_.closeConfirmation = StringToCloseConfirmationMode(closeConfirmStr.ToStdString());
 
        mainPanelSettings_.nextSceneHotkey = config.Read("NextSceneHotkey", "Ctrl+Tab");
        mainPanelSettings_.previousSceneHotkey = config.Read("PreviousSceneHotkey", "Ctrl+Shift+Tab");
        mainPanelSettings_.showMinimap = config.ReadBool("ShowMinimap", true);
        mainPanelSettings_.showCanvasBreadcrumb = config.ReadBool("ShowCanvasBreadcrumb", true);
 
        // Load behavior tree view settings
        config.SetPath("/BehaviorTreeView");
        behaviorTreeViewSettings_.zoomStepSize = config.ReadDouble("ZoomStepSize", 0.1);
        behaviorTreeViewSettings_.mouseWheelSensitivity = config.ReadDouble("MouseWheelSensitivity", 1.0);
        behaviorTreeViewSettings_.zoomFollowsCursor = config.ReadBool("ZoomFollowsCursor", true);
        behaviorTreeViewSettings_.resetViewHotkey = config.Read("ResetViewHotkey", "R");
        behaviorTreeViewSettings_.panSensitivity = config.ReadDouble("PanSensitivity", 1.51);
        behaviorTreeViewSettings_.panKey = config.Read("PanKey", "Middle Mouse Button");
        behaviorTreeViewSettings_.enableSmoothPanning = config.ReadBool("EnableSmoothPanning", false);
        behaviorTreeViewSettings_.panSmoothness = config.ReadDouble("PanSmoothness", 30.0);
        behaviorTreeViewSettings_.panStepSize = config.ReadDouble("PanStepSize", 40.0);
        behaviorTreeViewSettings_.centerOnNodeHotkey = config.Read("CenterOnNodeHotkey", "C");
        behaviorTreeViewSettings_.deleteNodeHotkey = config.Read("DeleteNodeHotkey", "Delete");
        behaviorTreeViewSettings_.panUpHotkey = config.Read("PanUpHotkey", "Up");
        behaviorTreeViewSettings_.panDownHotkey = config.Read("PanDownHotkey", "Down");
        behaviorTreeViewSettings_.panLeftHotkey = config.Read("PanLeftHotkey", "Left");
        behaviorTreeViewSettings_.panRightHotkey = config.Read("PanRightHotkey", "Right");
 
        // Load debug text - Coordinate System Info settings
        behaviorTreeViewSettings_.showCoordinateInfo = config.ReadBool("ShowCoordinateInfo", true);
        behaviorTreeViewSettings_.coordinateInfoFontSize = config.Read("CoordinateInfoFontSize", 9L);
        r = config.Read("CoordinateInfoR", 200L);
        g = config.Read("CoordinateInfoG", 200L);
        b = config.Read("CoordinateInfoB", 200L);
        behaviorTreeViewSettings_.coordinateInfoColor = EmberCore::Color(r, g, b);
        behaviorTreeViewSettings_.coordinateInfoAnchor =
            static_cast<TextAnchor>(config.Read("CoordinateInfoAnchor", 0L));
        behaviorTreeViewSettings_.coordinateInfoX = config.Read("CoordinateInfoX", 10L);
        behaviorTreeViewSettings_.coordinateInfoY = config.Read("CoordinateInfoY", 10L);
 
        // Load debug text - Selected Node Info settings
        behaviorTreeViewSettings_.showSelectedNodeInfo = config.ReadBool("ShowSelectedNodeInfo", true);
        behaviorTreeViewSettings_.selectedNodeInfoFontSize = config.Read("SelectedNodeInfoFontSize", 9L);
        r = config.Read("SelectedNodeInfoR", 100L);
        g = config.Read("SelectedNodeInfoG", 150L);
        b = config.Read("SelectedNodeInfoB", 255L);
        behaviorTreeViewSettings_.selectedNodeInfoColor = EmberCore::Color(r, g, b);
        behaviorTreeViewSettings_.selectedNodeInfoAnchor =
            static_cast<TextAnchor>(config.Read("SelectedNodeInfoAnchor", 0L));
        behaviorTreeViewSettings_.selectedNodeInfoX = config.Read("SelectedNodeInfoX", 10L);
        behaviorTreeViewSettings_.selectedNodeInfoY = config.Read("SelectedNodeInfoY", 30L);
 
        // Load debug text - Tree Statistics Info settings
        behaviorTreeViewSettings_.showTreeInfo = config.ReadBool("ShowTreeInfo", true);
        behaviorTreeViewSettings_.treeInfoFontSize = config.Read("TreeInfoFontSize", 9L);
        r = config.Read("TreeInfoR", 150L);
        g = config.Read("TreeInfoG", 200L);
        b = config.Read("TreeInfoB", 150L);
        behaviorTreeViewSettings_.treeInfoColor = EmberCore::Color(r, g, b);
        behaviorTreeViewSettings_.treeInfoAnchor = static_cast<TextAnchor>(config.Read("TreeInfoAnchor", 0L));
        behaviorTreeViewSettings_.treeInfoX = config.Read("TreeInfoX", 10L);
        behaviorTreeViewSettings_.treeInfoY = config.Read("TreeInfoY", 50L);
 
        // Load debug text - FPS Display settings
        behaviorTreeViewSettings_.showFPS = config.ReadBool("ShowFPS", true);
        behaviorTreeViewSettings_.fpsFontSize = config.Read("FPSFontSize", 9L);
        r = config.Read("FPSR", 255L);
        g = config.Read("FPSG", 200L);
        b = config.Read("FPSB", 100L);
        behaviorTreeViewSettings_.fpsColor = EmberCore::Color(r, g, b);
        behaviorTreeViewSettings_.fpsAnchor = static_cast<TextAnchor>(config.Read("FPSAnchor", 0L));
        behaviorTreeViewSettings_.fpsX = config.Read("FPSX", 10L);
        behaviorTreeViewSettings_.fpsY = config.Read("FPSY", 70L);
 
        // Load debug text - Controls Help Text settings
        behaviorTreeViewSettings_.showControlsHelp = config.ReadBool("ShowControlsHelp", true);
        behaviorTreeViewSettings_.controlsHelpFontSize = config.Read("ControlsHelpFontSize", 11L);
        r = config.Read("ControlsHelpR", 85L);
        g = config.Read("ControlsHelpG", 87L);
        b = config.Read("ControlsHelpB", 83L);
        behaviorTreeViewSettings_.controlsHelpColor = EmberCore::Color(r, g, b);
        behaviorTreeViewSettings_.controlsHelpAnchor =
            static_cast<TextAnchor>(config.Read("ControlsHelpAnchor", 2L)); // Default to Bottom-Left
        behaviorTreeViewSettings_.controlsHelpX = config.Read("ControlsHelpX", 10L);
        behaviorTreeViewSettings_.controlsHelpY = config.Read("ControlsHelpY", 25L);
 
        // Load bottom panel settings
        config.SetPath("/BottomPanel");
 
        // Panel layout settings
        bottomPanelSettings_.defaultPanelHeightPct = config.Read("DefaultPanelHeightPct", 25L);
        bottomPanelSettings_.defaultPanelHeightEnabled = config.ReadBool("DefaultPanelHeightEnabled", true);
        bottomPanelSettings_.minimumPanelHeightPct = config.Read("MinimumPanelHeightPct", 15L);
        bottomPanelSettings_.minimumPanelHeightEnabled = config.ReadBool("MinimumPanelHeightEnabled", true);
        wxString startupStateStr = config.Read("PanelStartupState", "Show");
        bottomPanelSettings_.panelStartupState = StringToPanelStartupState(startupStateStr.ToStdString());
        bottomPanelSettings_.lastPanelVisible = config.ReadBool("LastPanelVisible", true);
 
        // Tab bar settings
        bottomPanelSettings_.showTabCloseButtons = config.ReadBool("ShowTabCloseButtons", true);
 
        // Behavior settings
        bottomPanelSettings_.rememberLastTab = config.ReadBool("RememberLastTab", true);
        bottomPanelSettings_.allowPanelCollapse = config.ReadBool("AllowPanelCollapse", true);
        bottomPanelSettings_.lastActiveTab = config.Read("LastActiveTab", "FileExplorer").ToStdString();
 
        // Load lastOpenTabs as a comma-separated list
        wxString lastOpenTabsStr = config.Read("LastOpenTabs", "FileExplorer,Log");
        bottomPanelSettings_.lastOpenTabs.clear();
        wxStringTokenizer tokenizer(lastOpenTabsStr, ",");
        while (tokenizer.HasMoreTokens()) {
            wxString token = tokenizer.GetNextToken().Trim().Trim(false);
            if (!token.IsEmpty()) {
                bottomPanelSettings_.lastOpenTabs.push_back(token.ToStdString());
            }
        }
 
        // File Explorer general settings
        bottomPanelSettings_.showBreadcrumb = config.ReadBool("ShowBreadcrumb", true);
        bottomPanelSettings_.showHistory = config.ReadBool("ShowHistory", true);
        wxString startPathModeStr = config.Read("StartPathMode", "ExecutableDirectory");
        bottomPanelSettings_.startPathMode = StringToStartPathMode(startPathModeStr.ToStdString());
        bottomPanelSettings_.customStartPath = config.Read("CustomStartPath", "").ToStdString();
 
        // Tree View settings
        config.SetPath("/BottomPanel/TreeView");
        bottomPanelSettings_.treeView.showHiddenFiles = config.ReadBool("ShowHiddenFiles", false);
        bottomPanelSettings_.treeView.showFileExtensions = config.ReadBool("ShowFileExtensions", true);
        wxString treeViewSortByStr = config.Read("SortFilesBy", "Name");
        bottomPanelSettings_.treeView.sortFilesBy = StringToSortBy(treeViewSortByStr.ToStdString());
        wxString treeItemSizeStr = config.Read("ItemSize", "Medium");
        bottomPanelSettings_.treeView.itemSize = StringToTreeItemSize(treeItemSizeStr.ToStdString());
 
        // Grid View settings
        config.SetPath("/BottomPanel/GridView");
        bottomPanelSettings_.gridView.showHiddenFiles = config.ReadBool("ShowHiddenFiles", false);
        bottomPanelSettings_.gridView.showFileExtensions = config.ReadBool("ShowFileExtensions", true);
        wxString gridSortByStr = config.Read("SortFilesBy", "Name");
        bottomPanelSettings_.gridView.sortFilesBy = StringToSortBy(gridSortByStr.ToStdString());
        wxString iconSizeStr = config.Read("IconSize", "Medium");
        bottomPanelSettings_.gridView.iconSize = StringToIconSize(iconSizeStr.ToStdString());
 
        // Log Tab settings
        config.SetPath("/BottomPanel/LogTab");
        bottomPanelSettings_.logTab.defaultLevelFilter = config.ReadLong("DefaultLevelFilter", 3);
        bottomPanelSettings_.logTab.autoScrollEnabled = config.ReadBool("AutoScrollEnabled", true);
        bottomPanelSettings_.logTab.maxLogEntries = config.ReadLong("MaxLogEntries", 2000);
        wxString logFontSizeStr = config.Read("FontSize", "Medium");
        bottomPanelSettings_.logTab.fontSize = StringToLogFontSize(logFontSizeStr.ToStdString());
 
        // Color settings
        bottomPanelSettings_.logTab.enableGuiColors = config.ReadBool("EnableGuiColors", true);
        bottomPanelSettings_.logTab.enableConsoleColors = config.ReadBool("EnableConsoleColors", true);
 
        // Log level colors
        config.SetPath("/BottomPanel/LogTab/Colors");
        bottomPanelSettings_.logTab.traceColor.r = config.ReadLong("TraceR", 128);
        bottomPanelSettings_.logTab.traceColor.g = config.ReadLong("TraceG", 128);
        bottomPanelSettings_.logTab.traceColor.b = config.ReadLong("TraceB", 128);
        bottomPanelSettings_.logTab.infoColor.r = config.ReadLong("InfoR", 100);
        bottomPanelSettings_.logTab.infoColor.g = config.ReadLong("InfoG", 200);
        bottomPanelSettings_.logTab.infoColor.b = config.ReadLong("InfoB", 100);
        bottomPanelSettings_.logTab.warningColor.r = config.ReadLong("WarningR", 230);
        bottomPanelSettings_.logTab.warningColor.g = config.ReadLong("WarningG", 180);
        bottomPanelSettings_.logTab.warningColor.b = config.ReadLong("WarningB", 50);
        bottomPanelSettings_.logTab.errorColor.r = config.ReadLong("ErrorR", 230);
        bottomPanelSettings_.logTab.errorColor.g = config.ReadLong("ErrorG", 80);
        bottomPanelSettings_.logTab.errorColor.b = config.ReadLong("ErrorB", 80);
        bottomPanelSettings_.logTab.criticalColor.r = config.ReadLong("CriticalR", 255);
        bottomPanelSettings_.logTab.criticalColor.g = config.ReadLong("CriticalG", 50);
        bottomPanelSettings_.logTab.criticalColor.b = config.ReadLong("CriticalB", 50);
 
        // Reset path for next section
        config.SetPath("/");
 
        // Load global side panel settings (currently empty, reserved for future use)
        config.SetPath("/SidePanel");
        // Future global settings that affect all panels would be loaded here
        config.SetPath("/");
 
        // Load left panel settings
        config.SetPath("/LeftPanel");
 
        // Panel layout settings
        leftPanelSettings_.defaultPanelWidthPct = config.ReadLong("DefaultPanelWidthPct", 20);
        leftPanelSettings_.defaultPanelWidthEnabled = config.ReadBool("DefaultPanelWidthEnabled", true);
        leftPanelSettings_.minimumPanelWidthPct = config.ReadLong("MinimumPanelWidthPct", 10);
        leftPanelSettings_.minimumPanelWidthEnabled = config.ReadBool("MinimumPanelWidthEnabled", true);
        wxString leftPanelStartupStr = config.Read("PanelStartupState", "Show");
        leftPanelSettings_.panelStartupState = StringToPanelStartupState(leftPanelStartupStr.ToStdString());
        leftPanelSettings_.lastPanelVisible = config.ReadBool("LastPanelVisible", true);
 
        // Tab bar settings
        leftPanelSettings_.showTabCloseButtons = config.ReadBool("ShowTabCloseButtons", true);
 
        // Behavior settings
        leftPanelSettings_.rememberLastTab = config.ReadBool("RememberLastTab", true);
        leftPanelSettings_.allowPanelCollapse = config.ReadBool("AllowPanelCollapse", true);
        leftPanelSettings_.defaultActiveTab = config.Read("DefaultActiveTab", "Navigator").ToStdString();
        leftPanelSettings_.lastActiveTab = config.Read("LastActiveTab", "Navigator").ToStdString();
 
        // Load lastOpenTabs as a comma-separated list
        wxString leftOpenTabsStr = config.Read("LastOpenTabs", "Hierarchy");
        leftPanelSettings_.lastOpenTabs.clear();
        wxStringTokenizer leftTokenizer(leftOpenTabsStr, ",");
        while (leftTokenizer.HasMoreTokens()) {
            wxString token = leftTokenizer.GetNextToken().Trim().Trim(false);
            if (!token.IsEmpty()) {
                leftPanelSettings_.lastOpenTabs.push_back(token.ToStdString());
            }
        }
 
        config.SetPath("/");
 
        // Load right panel settings
        config.SetPath("/RightPanel");
 
        // Panel layout settings
        rightPanelSettings_.defaultPanelWidthPct = config.ReadLong("DefaultPanelWidthPct", 20);
        rightPanelSettings_.defaultPanelWidthEnabled = config.ReadBool("DefaultPanelWidthEnabled", true);
        rightPanelSettings_.minimumPanelWidthPct = config.ReadLong("MinimumPanelWidthPct", 10);
        rightPanelSettings_.minimumPanelWidthEnabled = config.ReadBool("MinimumPanelWidthEnabled", true);
        wxString rightPanelStartupStr = config.Read("PanelStartupState", "Show");
        rightPanelSettings_.panelStartupState = StringToPanelStartupState(rightPanelStartupStr.ToStdString());
        rightPanelSettings_.lastPanelVisible = config.ReadBool("LastPanelVisible", true);
 
        // Tab bar settings
        rightPanelSettings_.showTabCloseButtons = config.ReadBool("ShowTabCloseButtons", true);
 
        // Behavior settings
        rightPanelSettings_.rememberLastTab = config.ReadBool("RememberLastTab", true);
        rightPanelSettings_.allowPanelCollapse = config.ReadBool("AllowPanelCollapse", true);
        rightPanelSettings_.defaultActiveTab = config.Read("DefaultActiveTab", "Properties").ToStdString();
        rightPanelSettings_.lastActiveTab = config.Read("LastActiveTab", "Properties").ToStdString();
 
        // Load lastOpenTabs as a comma-separated list
        wxString rightOpenTabsStr = config.Read("LastOpenTabs", "Properties");
        rightPanelSettings_.lastOpenTabs.clear();
        wxStringTokenizer rightTokenizer(rightOpenTabsStr, ",");
        while (rightTokenizer.HasMoreTokens()) {
            wxString token = rightTokenizer.GetNextToken().Trim().Trim(false);
            if (!token.IsEmpty()) {
                rightPanelSettings_.lastOpenTabs.push_back(token.ToStdString());
            }
        }
 
        // Reset path for next section
        config.SetPath("/");
 
        // Load parser settings
        config.SetPath("/Parser");
        parserSettings_.autoLoadLastFile = config.ReadBool("AutoLoadLastFile", false);
        parserSettings_.lastOpenedFilePath = config.Read("LastOpenedFilePath", "").ToStdString();
        parserSettings_.defaultFileEncoding = config.Read("DefaultFileEncoding", "UTF-8").ToStdString();
        parserSettings_.showParseWarnings = config.ReadBool("ShowParseWarnings", true);
 
        // Load performance settings
        config.SetPath("/Performance");
 
        // Rendering settings
        performanceSettings_.enableVSync = config.ReadBool("EnableVSync", true);
        performanceSettings_.hardwareAcceleration = config.ReadBool("HardwareAcceleration", true);
        performanceSettings_.enableDoubleBuffering = config.ReadBool("EnableDoubleBuffering", true);
        performanceSettings_.enableAntiAliasing = config.ReadBool("EnableAntiAliasing", true);
        performanceSettings_.enableTextAntiAliasing = config.ReadBool("EnableTextAntiAliasing", true);
        performanceSettings_.enablePartialRedraws = config.ReadBool("EnablePartialRedraws", true);
        performanceSettings_.enableBackgroundErase = config.ReadBool("EnableBackgroundErase", false);
 
        // Viewport culling settings
        performanceSettings_.enableViewportCulling = config.ReadBool("EnableViewportCulling", true);
        performanceSettings_.viewportCullingMargin = config.Read("ViewportCullingMargin", 500L);
 
        wxString fpsLimitStr = config.Read("FPSLimit", "FPS_60");
        performanceSettings_.fpsLimit = StringToFPSLimit(fpsLimitStr.ToStdString());
 
        // UI responsiveness settings
        performanceSettings_.enableIdleProcessing = config.ReadBool("EnableIdleProcessing", true);
 
        LOG_INFO("AppPreferences", "Preferences loaded successfully");
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("AppPreferences", "Error loading preferences: " + std::string(e.what()));
        return false;
    }
}
 
bool AppPreferences::SaveToFile(const EmberCore::String &filename) const {
    LOG_INFO("AppPreferences", "Saving preferences to: " + filename);
 
    try {
        // Ensure directory exists
        wxFileName fn(filename);
        if (!fn.DirExists()) {
            if (!fn.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL)) {
                LOG_ERROR("AppPreferences", "Failed to create config directory");
                return false;
            }
        }
 
        wxFileConfig config(wxEmptyString, wxEmptyString, filename, wxEmptyString,
                            wxCONFIG_USE_LOCAL_FILE | wxCONFIG_USE_RELATIVE_PATH);
 
        // Save window settings
        config.SetPath("/Window");
        config.Write("WindowX", windowSettings_.windowX);
        config.Write("WindowY", windowSettings_.windowY);
        config.Write("WindowWidth", windowSettings_.windowWidth);
        config.Write("WindowHeight", windowSettings_.windowHeight);
        config.Write("StartupMode", wxString(StartupModeToString(windowSettings_.startupMode)));
        config.Write("MaximizeHotkey", wxString(windowSettings_.maximizeHotkey));
 
        // File menu hotkeys
        config.Write("NewProjectHotkey", wxString(windowSettings_.newProjectHotkey));
        config.Write("OpenProjectHotkey", wxString(windowSettings_.openProjectHotkey));
        config.Write("OpenFileHotkey", wxString(windowSettings_.openFileHotkey));
        config.Write("SaveHotkey", wxString(windowSettings_.saveHotkey));
        config.Write("SaveAsHotkey", wxString(windowSettings_.saveAsHotkey));
 
        // View menu hotkeys
        config.Write("ResetUIHotkey", wxString(windowSettings_.resetUIHotkey));
 
        // Settings menu hotkeys
        config.Write("PreferencesHotkey", wxString(windowSettings_.preferencesHotkey));
        config.Write("ParserConfigHotkey", wxString(windowSettings_.parserConfigHotkey));
 
        config.Write("Theme", wxString(ThemeModeToString(windowSettings_.theme)));
        config.Write("AccentColorR", static_cast<long>(windowSettings_.accentColor.r));
        config.Write("AccentColorG", static_cast<long>(windowSettings_.accentColor.g));
        config.Write("AccentColorB", static_cast<long>(windowSettings_.accentColor.b));
 
        // Window appearance and behavior
        config.Write("ShowStatusBar", windowSettings_.showStatusBar);
        config.Write("ShowPanelCaptions", windowSettings_.showPanelCaptions);
        config.Write("AlwaysOnTop", windowSettings_.alwaysOnTop);
 
        // Window constraints (percentage of screen)
        config.Write("MinWindowWidthPct", windowSettings_.minWindowWidthPct);
        config.Write("MinWindowHeightPct", windowSettings_.minWindowHeightPct);
        config.Write("MaxWindowWidthPct", windowSettings_.maxWindowWidthPct);
        config.Write("MaxWindowHeightPct", windowSettings_.maxWindowHeightPct);
        config.Write("EnforceAspectRatio", windowSettings_.enforceAspectRatio);
        config.Write("AspectRatio", windowSettings_.aspectRatio);
 
        // Save main panel settings
        config.SetPath("/MainPanel");
        config.Write("DefaultZoomLevel", mainPanelSettings_.defaultZoomLevel);
        config.Write("ShowGrid", mainPanelSettings_.showGrid);
        config.Write("GridSize", mainPanelSettings_.gridSize);
        config.Write("GridBackgroundR", static_cast<long>(mainPanelSettings_.gridBackgroundColor.r));
        config.Write("GridBackgroundG", static_cast<long>(mainPanelSettings_.gridBackgroundColor.g));
        config.Write("GridBackgroundB", static_cast<long>(mainPanelSettings_.gridBackgroundColor.b));
        config.Write("GridLineR", static_cast<long>(mainPanelSettings_.gridLineColor.r));
        config.Write("GridLineG", static_cast<long>(mainPanelSettings_.gridLineColor.g));
        config.Write("GridLineB", static_cast<long>(mainPanelSettings_.gridLineColor.b));
        config.Write("SnapToGrid", mainPanelSettings_.snapToGrid);
        config.Write("CanvasBackgroundR", static_cast<long>(mainPanelSettings_.canvasBackgroundColor.r));
        config.Write("CanvasBackgroundG", static_cast<long>(mainPanelSettings_.canvasBackgroundColor.g));
        config.Write("CanvasBackgroundB", static_cast<long>(mainPanelSettings_.canvasBackgroundColor.b));
        config.Write("ConnectionLineR", static_cast<long>(mainPanelSettings_.connectionLineColor.r));
        config.Write("ConnectionLineG", static_cast<long>(mainPanelSettings_.connectionLineColor.g));
        config.Write("ConnectionLineB", static_cast<long>(mainPanelSettings_.connectionLineColor.b));
        config.Write("HighlightPathToSelected", mainPanelSettings_.highlightPathToSelected);
        config.Write("PathHighlightR", static_cast<long>(mainPanelSettings_.pathHighlightColor.r));
        config.Write("PathHighlightG", static_cast<long>(mainPanelSettings_.pathHighlightColor.g));
        config.Write("PathHighlightB", static_cast<long>(mainPanelSettings_.pathHighlightColor.b));
        config.Write("IdleNodeBgR", static_cast<long>(mainPanelSettings_.idleNodeBgColor.r));
        config.Write("IdleNodeBgG", static_cast<long>(mainPanelSettings_.idleNodeBgColor.g));
        config.Write("IdleNodeBgB", static_cast<long>(mainPanelSettings_.idleNodeBgColor.b));
        config.Write("IdleNodeBorderR", static_cast<long>(mainPanelSettings_.idleNodeBorderColor.r));
        config.Write("IdleNodeBorderG", static_cast<long>(mainPanelSettings_.idleNodeBorderColor.g));
        config.Write("IdleNodeBorderB", static_cast<long>(mainPanelSettings_.idleNodeBorderColor.b));
        config.Write("IdleNodeTextR", static_cast<long>(mainPanelSettings_.idleNodeTextColor.r));
        config.Write("IdleNodeTextG", static_cast<long>(mainPanelSettings_.idleNodeTextColor.g));
        config.Write("IdleNodeTextB", static_cast<long>(mainPanelSettings_.idleNodeTextColor.b));
        config.Write("SelectedNodeBgTint", static_cast<long>(mainPanelSettings_.selectedNodeBgTint * 100));
        config.Write("HoveredNodeBgTint", static_cast<long>(mainPanelSettings_.hoveredNodeBgTint * 100));
        config.Write("SelectedNodeR", static_cast<long>(mainPanelSettings_.selectedNodeColor.r));
        config.Write("SelectedNodeG", static_cast<long>(mainPanelSettings_.selectedNodeColor.g));
        config.Write("SelectedNodeB", static_cast<long>(mainPanelSettings_.selectedNodeColor.b));
        config.Write("HoveredNodeR", static_cast<long>(mainPanelSettings_.hoveredNodeColor.r));
        config.Write("HoveredNodeG", static_cast<long>(mainPanelSettings_.hoveredNodeColor.g));
        config.Write("HoveredNodeB", static_cast<long>(mainPanelSettings_.hoveredNodeColor.b));
        config.Write("SelectedNodeTextR", static_cast<long>(mainPanelSettings_.selectedNodeTextColor.r));
        config.Write("SelectedNodeTextG", static_cast<long>(mainPanelSettings_.selectedNodeTextColor.g));
        config.Write("SelectedNodeTextB", static_cast<long>(mainPanelSettings_.selectedNodeTextColor.b));
        config.Write("HoveredNodeTextR", static_cast<long>(mainPanelSettings_.hoveredNodeTextColor.r));
        config.Write("HoveredNodeTextG", static_cast<long>(mainPanelSettings_.hoveredNodeTextColor.g));
        config.Write("HoveredNodeTextB", static_cast<long>(mainPanelSettings_.hoveredNodeTextColor.b));
        config.Write("SelectedNodeInfoR", static_cast<long>(mainPanelSettings_.selectedNodeInfoColor.r));
        config.Write("SelectedNodeInfoG", static_cast<long>(mainPanelSettings_.selectedNodeInfoColor.g));
        config.Write("SelectedNodeInfoB", static_cast<long>(mainPanelSettings_.selectedNodeInfoColor.b));
        config.Write("HoveredNodeInfoR", static_cast<long>(mainPanelSettings_.hoveredNodeInfoColor.r));
        config.Write("HoveredNodeInfoG", static_cast<long>(mainPanelSettings_.hoveredNodeInfoColor.g));
        config.Write("HoveredNodeInfoB", static_cast<long>(mainPanelSettings_.hoveredNodeInfoColor.b));
        config.Write("MaxScenes", mainPanelSettings_.maxScenes);
        config.Write("CloseConfirmation",
                     wxString(CloseConfirmationModeToString(mainPanelSettings_.closeConfirmation)));
        config.Write("NextSceneHotkey", wxString(mainPanelSettings_.nextSceneHotkey));
        config.Write("PreviousSceneHotkey", wxString(mainPanelSettings_.previousSceneHotkey));
        config.Write("ShowMinimap", mainPanelSettings_.showMinimap);
        config.Write("ShowCanvasBreadcrumb", mainPanelSettings_.showCanvasBreadcrumb);
 
        // Save behavior tree view settings
        config.SetPath("/BehaviorTreeView");
        config.Write("ZoomStepSize", behaviorTreeViewSettings_.zoomStepSize);
        config.Write("MouseWheelSensitivity", behaviorTreeViewSettings_.mouseWheelSensitivity);
        config.Write("ZoomFollowsCursor", behaviorTreeViewSettings_.zoomFollowsCursor);
        config.Write("ResetViewHotkey", wxString(behaviorTreeViewSettings_.resetViewHotkey));
        config.Write("PanSensitivity", behaviorTreeViewSettings_.panSensitivity);
        config.Write("PanKey", wxString(behaviorTreeViewSettings_.panKey));
        config.Write("EnableSmoothPanning", behaviorTreeViewSettings_.enableSmoothPanning);
        config.Write("PanSmoothness", behaviorTreeViewSettings_.panSmoothness);
        config.Write("PanStepSize", behaviorTreeViewSettings_.panStepSize);
        config.Write("CenterOnNodeHotkey", wxString(behaviorTreeViewSettings_.centerOnNodeHotkey));
        config.Write("DeleteNodeHotkey", wxString(behaviorTreeViewSettings_.deleteNodeHotkey));
        config.Write("PanUpHotkey", wxString(behaviorTreeViewSettings_.panUpHotkey));
        config.Write("PanDownHotkey", wxString(behaviorTreeViewSettings_.panDownHotkey));
        config.Write("PanLeftHotkey", wxString(behaviorTreeViewSettings_.panLeftHotkey));
        config.Write("PanRightHotkey", wxString(behaviorTreeViewSettings_.panRightHotkey));
 
        // Save debug text - Coordinate System Info settings
        config.Write("ShowCoordinateInfo", behaviorTreeViewSettings_.showCoordinateInfo);
        config.Write("CoordinateInfoFontSize", behaviorTreeViewSettings_.coordinateInfoFontSize);
        config.Write("CoordinateInfoR", static_cast<long>(behaviorTreeViewSettings_.coordinateInfoColor.r));
        config.Write("CoordinateInfoG", static_cast<long>(behaviorTreeViewSettings_.coordinateInfoColor.g));
        config.Write("CoordinateInfoB", static_cast<long>(behaviorTreeViewSettings_.coordinateInfoColor.b));
        config.Write("CoordinateInfoAnchor", static_cast<int>(behaviorTreeViewSettings_.coordinateInfoAnchor));
        config.Write("CoordinateInfoX", behaviorTreeViewSettings_.coordinateInfoX);
        config.Write("CoordinateInfoY", behaviorTreeViewSettings_.coordinateInfoY);
 
        // Save debug text - Selected Node Info settings
        config.Write("ShowSelectedNodeInfo", behaviorTreeViewSettings_.showSelectedNodeInfo);
        config.Write("SelectedNodeInfoFontSize", behaviorTreeViewSettings_.selectedNodeInfoFontSize);
        config.Write("SelectedNodeInfoR", static_cast<long>(behaviorTreeViewSettings_.selectedNodeInfoColor.r));
        config.Write("SelectedNodeInfoG", static_cast<long>(behaviorTreeViewSettings_.selectedNodeInfoColor.g));
        config.Write("SelectedNodeInfoB", static_cast<long>(behaviorTreeViewSettings_.selectedNodeInfoColor.b));
        config.Write("SelectedNodeInfoAnchor", static_cast<int>(behaviorTreeViewSettings_.selectedNodeInfoAnchor));
        config.Write("SelectedNodeInfoX", behaviorTreeViewSettings_.selectedNodeInfoX);
        config.Write("SelectedNodeInfoY", behaviorTreeViewSettings_.selectedNodeInfoY);
 
        // Save debug text - Tree Statistics Info settings
        config.Write("ShowTreeInfo", behaviorTreeViewSettings_.showTreeInfo);
        config.Write("TreeInfoFontSize", behaviorTreeViewSettings_.treeInfoFontSize);
        config.Write("TreeInfoR", static_cast<long>(behaviorTreeViewSettings_.treeInfoColor.r));
        config.Write("TreeInfoG", static_cast<long>(behaviorTreeViewSettings_.treeInfoColor.g));
        config.Write("TreeInfoB", static_cast<long>(behaviorTreeViewSettings_.treeInfoColor.b));
        config.Write("TreeInfoAnchor", static_cast<int>(behaviorTreeViewSettings_.treeInfoAnchor));
        config.Write("TreeInfoX", behaviorTreeViewSettings_.treeInfoX);
        config.Write("TreeInfoY", behaviorTreeViewSettings_.treeInfoY);
 
        // Save debug text - FPS Display settings
        config.Write("ShowFPS", behaviorTreeViewSettings_.showFPS);
        config.Write("FPSFontSize", behaviorTreeViewSettings_.fpsFontSize);
        config.Write("FPSR", static_cast<long>(behaviorTreeViewSettings_.fpsColor.r));
        config.Write("FPSG", static_cast<long>(behaviorTreeViewSettings_.fpsColor.g));
        config.Write("FPSB", static_cast<long>(behaviorTreeViewSettings_.fpsColor.b));
        config.Write("FPSAnchor", static_cast<int>(behaviorTreeViewSettings_.fpsAnchor));
        config.Write("FPSX", behaviorTreeViewSettings_.fpsX);
        config.Write("FPSY", behaviorTreeViewSettings_.fpsY);
 
        // Save debug text - Controls Help Text settings
        config.Write("ShowControlsHelp", behaviorTreeViewSettings_.showControlsHelp);
        config.Write("ControlsHelpFontSize", behaviorTreeViewSettings_.controlsHelpFontSize);
        config.Write("ControlsHelpR", static_cast<long>(behaviorTreeViewSettings_.controlsHelpColor.r));
        config.Write("ControlsHelpG", static_cast<long>(behaviorTreeViewSettings_.controlsHelpColor.g));
        config.Write("ControlsHelpB", static_cast<long>(behaviorTreeViewSettings_.controlsHelpColor.b));
        config.Write("ControlsHelpAnchor", static_cast<int>(behaviorTreeViewSettings_.controlsHelpAnchor));
        config.Write("ControlsHelpX", behaviorTreeViewSettings_.controlsHelpX);
        config.Write("ControlsHelpY", behaviorTreeViewSettings_.controlsHelpY);
 
        // Save bottom panel settings
        config.SetPath("/BottomPanel");
 
        // Panel layout settings
        config.Write("DefaultPanelHeightPct", bottomPanelSettings_.defaultPanelHeightPct);
        config.Write("DefaultPanelHeightEnabled", bottomPanelSettings_.defaultPanelHeightEnabled);
        config.Write("MinimumPanelHeightPct", bottomPanelSettings_.minimumPanelHeightPct);
        config.Write("MinimumPanelHeightEnabled", bottomPanelSettings_.minimumPanelHeightEnabled);
        config.Write("PanelStartupState", wxString(PanelStartupStateToString(bottomPanelSettings_.panelStartupState)));
        config.Write("LastPanelVisible", bottomPanelSettings_.lastPanelVisible);
 
        // Tab bar settings
        config.Write("ShowTabCloseButtons", bottomPanelSettings_.showTabCloseButtons);
 
        // Behavior settings
        config.Write("RememberLastTab", bottomPanelSettings_.rememberLastTab);
        config.Write("AllowPanelCollapse", bottomPanelSettings_.allowPanelCollapse);
        config.Write("LastActiveTab", wxString(bottomPanelSettings_.lastActiveTab));
 
        // Save lastOpenTabs as a comma-separated list
        wxString bottomOpenTabsStr;
        for (size_t i = 0; i < bottomPanelSettings_.lastOpenTabs.size(); ++i) {
            if (i > 0)
                bottomOpenTabsStr += ",";
            bottomOpenTabsStr += wxString(bottomPanelSettings_.lastOpenTabs[i]);
        }
        config.Write("LastOpenTabs", bottomOpenTabsStr);
 
        // File Explorer general settings
        config.Write("ShowBreadcrumb", bottomPanelSettings_.showBreadcrumb);
        config.Write("ShowHistory", bottomPanelSettings_.showHistory);
        config.Write("StartPathMode", wxString(StartPathModeToString(bottomPanelSettings_.startPathMode)));
        config.Write("CustomStartPath", wxString(bottomPanelSettings_.customStartPath));
 
        // Tree View settings
        config.SetPath("/BottomPanel/TreeView");
        config.Write("ShowHiddenFiles", bottomPanelSettings_.treeView.showHiddenFiles);
        config.Write("ShowFileExtensions", bottomPanelSettings_.treeView.showFileExtensions);
        config.Write("SortFilesBy", wxString(SortByToString(bottomPanelSettings_.treeView.sortFilesBy)));
        config.Write("ItemSize", wxString(TreeItemSizeToString(bottomPanelSettings_.treeView.itemSize)));
 
        // Grid View settings
        config.SetPath("/BottomPanel/GridView");
        config.Write("ShowHiddenFiles", bottomPanelSettings_.gridView.showHiddenFiles);
        config.Write("ShowFileExtensions", bottomPanelSettings_.gridView.showFileExtensions);
        config.Write("SortFilesBy", wxString(SortByToString(bottomPanelSettings_.gridView.sortFilesBy)));
        config.Write("IconSize", wxString(IconSizeToString(bottomPanelSettings_.gridView.iconSize)));
 
        // Log Tab settings
        config.SetPath("/BottomPanel/LogTab");
        config.Write("DefaultLevelFilter", bottomPanelSettings_.logTab.defaultLevelFilter);
        config.Write("AutoScrollEnabled", bottomPanelSettings_.logTab.autoScrollEnabled);
        config.Write("MaxLogEntries", bottomPanelSettings_.logTab.maxLogEntries);
        config.Write("FontSize", wxString(LogFontSizeToString(bottomPanelSettings_.logTab.fontSize)));
 
        // Color settings
        config.Write("EnableGuiColors", bottomPanelSettings_.logTab.enableGuiColors);
        config.Write("EnableConsoleColors", bottomPanelSettings_.logTab.enableConsoleColors);
 
        // Log level colors
        config.SetPath("/BottomPanel/LogTab/Colors");
        config.Write("TraceR", bottomPanelSettings_.logTab.traceColor.r);
        config.Write("TraceG", bottomPanelSettings_.logTab.traceColor.g);
        config.Write("TraceB", bottomPanelSettings_.logTab.traceColor.b);
        config.Write("InfoR", bottomPanelSettings_.logTab.infoColor.r);
        config.Write("InfoG", bottomPanelSettings_.logTab.infoColor.g);
        config.Write("InfoB", bottomPanelSettings_.logTab.infoColor.b);
        config.Write("WarningR", bottomPanelSettings_.logTab.warningColor.r);
        config.Write("WarningG", bottomPanelSettings_.logTab.warningColor.g);
        config.Write("WarningB", bottomPanelSettings_.logTab.warningColor.b);
        config.Write("ErrorR", bottomPanelSettings_.logTab.errorColor.r);
        config.Write("ErrorG", bottomPanelSettings_.logTab.errorColor.g);
        config.Write("ErrorB", bottomPanelSettings_.logTab.errorColor.b);
        config.Write("CriticalR", bottomPanelSettings_.logTab.criticalColor.r);
        config.Write("CriticalG", bottomPanelSettings_.logTab.criticalColor.g);
        config.Write("CriticalB", bottomPanelSettings_.logTab.criticalColor.b);
 
        // Reset path for next section
        config.SetPath("/BottomPanel");
 
        // Save global side panel settings (currently empty, reserved for future use)
        config.SetPath("/SidePanel");
        // Future global settings that affect all panels would be saved here
        config.SetPath("/");
 
        // Save left panel settings
        config.SetPath("/LeftPanel");
 
        // Panel layout settings
        config.Write("DefaultPanelWidthPct", leftPanelSettings_.defaultPanelWidthPct);
        config.Write("DefaultPanelWidthEnabled", leftPanelSettings_.defaultPanelWidthEnabled);
        config.Write("MinimumPanelWidthPct", leftPanelSettings_.minimumPanelWidthPct);
        config.Write("MinimumPanelWidthEnabled", leftPanelSettings_.minimumPanelWidthEnabled);
        config.Write("PanelStartupState", wxString(PanelStartupStateToString(leftPanelSettings_.panelStartupState)));
        config.Write("LastPanelVisible", leftPanelSettings_.lastPanelVisible);
 
        // Tab bar settings
        config.Write("ShowTabCloseButtons", leftPanelSettings_.showTabCloseButtons);
 
        // Behavior settings
        config.Write("RememberLastTab", leftPanelSettings_.rememberLastTab);
        config.Write("AllowPanelCollapse", leftPanelSettings_.allowPanelCollapse);
        config.Write("DefaultActiveTab", wxString(leftPanelSettings_.defaultActiveTab));
        config.Write("LastActiveTab", wxString(leftPanelSettings_.lastActiveTab));
 
        // Save lastOpenTabs as a comma-separated list
        wxString leftOpenTabsStr;
        for (size_t i = 0; i < leftPanelSettings_.lastOpenTabs.size(); ++i) {
            if (i > 0)
                leftOpenTabsStr += ",";
            leftOpenTabsStr += wxString(leftPanelSettings_.lastOpenTabs[i]);
        }
        config.Write("LastOpenTabs", leftOpenTabsStr);
 
        config.SetPath("/");
 
        // Save right panel settings
        config.SetPath("/RightPanel");
 
        // Panel layout settings
        config.Write("DefaultPanelWidthPct", rightPanelSettings_.defaultPanelWidthPct);
        config.Write("DefaultPanelWidthEnabled", rightPanelSettings_.defaultPanelWidthEnabled);
        config.Write("MinimumPanelWidthPct", rightPanelSettings_.minimumPanelWidthPct);
        config.Write("MinimumPanelWidthEnabled", rightPanelSettings_.minimumPanelWidthEnabled);
        config.Write("PanelStartupState", wxString(PanelStartupStateToString(rightPanelSettings_.panelStartupState)));
        config.Write("LastPanelVisible", rightPanelSettings_.lastPanelVisible);
 
        // Tab bar settings
        config.Write("ShowTabCloseButtons", rightPanelSettings_.showTabCloseButtons);
 
        // Behavior settings
        config.Write("RememberLastTab", rightPanelSettings_.rememberLastTab);
        config.Write("AllowPanelCollapse", rightPanelSettings_.allowPanelCollapse);
        config.Write("DefaultActiveTab", wxString(rightPanelSettings_.defaultActiveTab));
        config.Write("LastActiveTab", wxString(rightPanelSettings_.lastActiveTab));
 
        // Save lastOpenTabs as a comma-separated list
        wxString rightOpenTabsStr;
        for (size_t i = 0; i < rightPanelSettings_.lastOpenTabs.size(); ++i) {
            if (i > 0)
                rightOpenTabsStr += ",";
            rightOpenTabsStr += wxString(rightPanelSettings_.lastOpenTabs[i]);
        }
        config.Write("LastOpenTabs", rightOpenTabsStr);
 
        // Save parser settings
        config.SetPath("/Parser");
        config.Write("AutoLoadLastFile", parserSettings_.autoLoadLastFile);
        config.Write("LastOpenedFilePath", wxString(parserSettings_.lastOpenedFilePath));
        config.Write("DefaultFileEncoding", wxString(parserSettings_.defaultFileEncoding));
        config.Write("ShowParseWarnings", parserSettings_.showParseWarnings);
 
        // Save performance settings
        config.SetPath("/Performance");
 
        // Rendering settings
        config.Write("EnableVSync", performanceSettings_.enableVSync);
        config.Write("HardwareAcceleration", performanceSettings_.hardwareAcceleration);
        config.Write("EnableDoubleBuffering", performanceSettings_.enableDoubleBuffering);
        config.Write("EnableAntiAliasing", performanceSettings_.enableAntiAliasing);
        config.Write("EnableTextAntiAliasing", performanceSettings_.enableTextAntiAliasing);
        config.Write("EnablePartialRedraws", performanceSettings_.enablePartialRedraws);
        config.Write("EnableBackgroundErase", performanceSettings_.enableBackgroundErase);
 
        // Viewport culling settings
        config.Write("EnableViewportCulling", performanceSettings_.enableViewportCulling);
        config.Write("ViewportCullingMargin", performanceSettings_.viewportCullingMargin);
 
        config.Write("FPSLimit", wxString(FPSLimitToString(performanceSettings_.fpsLimit)));
 
        // UI responsiveness settings
        config.Write("EnableIdleProcessing", performanceSettings_.enableIdleProcessing);
 
        config.Flush();
 
        LOG_INFO("AppPreferences", "Preferences saved successfully");
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("AppPreferences", "Error saving preferences: " + std::string(e.what()));
        return false;
    }
}
 
// Enum conversion helpers
AppPreferences::ThemeMode AppPreferences::StringToThemeMode(const std::string &str) {
    if (str == "Light")
        return ThemeMode::Light;
    return ThemeMode::Dark;
}
 
std::string AppPreferences::ThemeModeToString(ThemeMode mode) {
    switch (mode) {
    case ThemeMode::Light:
        return "Light";
    case ThemeMode::Dark:
        return "Dark";
    default:
        return "Dark";
    }
}
 
AppPreferences::StartupMode AppPreferences::StringToStartupMode(const std::string &str) {
    if (str == "Maximized")
        return StartupMode::Maximized;
    return StartupMode::Normal;
}
 
std::string AppPreferences::StartupModeToString(StartupMode mode) {
    switch (mode) {
    case StartupMode::Maximized:
        return "Maximized";
    case StartupMode::Normal:
        return "Normal";
    default:
        return "Normal";
    }
}
 
AppPreferences::SortBy AppPreferences::StringToSortBy(const std::string &str) {
    if (str == "Date")
        return SortBy::Date;
    if (str == "Size")
        return SortBy::Size;
    if (str == "Type")
        return SortBy::Type;
    return SortBy::Name;
}
 
std::string AppPreferences::SortByToString(SortBy sort) {
    switch (sort) {
    case SortBy::Date:
        return "Date";
    case SortBy::Size:
        return "Size";
    case SortBy::Type:
        return "Type";
    case SortBy::Name:
        return "Name";
    default:
        return "Name";
    }
}
 
AppPreferences::IconSize AppPreferences::StringToIconSize(const std::string &str) {
    if (str == "Small")
        return IconSize::Small;
    if (str == "Large")
        return IconSize::Large;
    return IconSize::Medium;
}
 
std::string AppPreferences::IconSizeToString(IconSize size) {
    switch (size) {
    case IconSize::Small:
        return "Small";
    case IconSize::Large:
        return "Large";
    case IconSize::Medium:
        return "Medium";
    default:
        return "Medium";
    }
}
 
AppPreferences::TreeItemSize AppPreferences::StringToTreeItemSize(const std::string &str) {
    if (str == "Small")
        return TreeItemSize::Small;
    if (str == "Large")
        return TreeItemSize::Large;
    return TreeItemSize::Medium;
}
 
std::string AppPreferences::TreeItemSizeToString(TreeItemSize size) {
    switch (size) {
    case TreeItemSize::Small:
        return "Small";
    case TreeItemSize::Large:
        return "Large";
    case TreeItemSize::Medium:
        return "Medium";
    default:
        return "Medium";
    }
}
 
AppPreferences::LogFontSize AppPreferences::StringToLogFontSize(const std::string &str) {
    if (str == "Small")
        return LogFontSize::Small;
    if (str == "Large")
        return LogFontSize::Large;
    return LogFontSize::Medium;
}
 
std::string AppPreferences::LogFontSizeToString(LogFontSize size) {
    switch (size) {
    case LogFontSize::Small:
        return "Small";
    case LogFontSize::Large:
        return "Large";
    case LogFontSize::Medium:
        return "Medium";
    default:
        return "Medium";
    }
}
 
AppPreferences::StartPathMode AppPreferences::StringToStartPathMode(const std::string &str) {
    if (str == "CustomPath")
        return StartPathMode::CustomPath;
    return StartPathMode::ExecutableDirectory;
}
 
std::string AppPreferences::StartPathModeToString(StartPathMode mode) {
    switch (mode) {
    case StartPathMode::ExecutableDirectory:
        return "ExecutableDirectory";
    case StartPathMode::CustomPath:
        return "CustomPath";
    default:
        return "ExecutableDirectory";
    }
}
 
AppPreferences::FPSLimit AppPreferences::StringToFPSLimit(const std::string &str) {
    if (str == "FPS_30")
        return FPSLimit::FPS_30;
    if (str == "FPS_120")
        return FPSLimit::FPS_120;
    if (str == "Unlimited")
        return FPSLimit::Unlimited;
    return FPSLimit::FPS_60;
}
 
std::string AppPreferences::FPSLimitToString(FPSLimit limit) {
    switch (limit) {
    case FPSLimit::FPS_30:
        return "FPS_30";
    case FPSLimit::FPS_60:
        return "FPS_60";
    case FPSLimit::FPS_120:
        return "FPS_120";
    case FPSLimit::Unlimited:
        return "Unlimited";
    default:
        return "FPS_60";
    }
}
 
AppPreferences::CloseConfirmationMode AppPreferences::StringToCloseConfirmationMode(const std::string &str) {
    if (str == "AlwaysAsk")
        return CloseConfirmationMode::AlwaysAsk;
    if (str == "NeverAsk")
        return CloseConfirmationMode::NeverAsk;
    if (str == "AskIfUnsaved")
        return CloseConfirmationMode::AskIfUnsaved;
    return CloseConfirmationMode::AskIfUnsaved; // Default
}
 
std::string AppPreferences::CloseConfirmationModeToString(CloseConfirmationMode mode) {
    switch (mode) {
    case CloseConfirmationMode::AlwaysAsk:
        return "AlwaysAsk";
    case CloseConfirmationMode::NeverAsk:
        return "NeverAsk";
    case CloseConfirmationMode::AskIfUnsaved:
        return "AskIfUnsaved";
    default:
        return "AskIfUnsaved";
    }
}
 
AppPreferences::PanelStartupState AppPreferences::StringToPanelStartupState(const std::string &str) {
    if (str == "Hide")
        return PanelStartupState::Hide;
    if (str == "RememberLast")
        return PanelStartupState::RememberLast;
    return PanelStartupState::Show;
}
 
std::string AppPreferences::PanelStartupStateToString(PanelStartupState state) {
    switch (state) {
    case PanelStartupState::Show:
        return "Show";
    case PanelStartupState::Hide:
        return "Hide";
    case PanelStartupState::RememberLast:
        return "RememberLast";
    default:
        return "Show";
    }
}
 
// Singleton implementation
AppPreferencesManager &AppPreferencesManager::GetInstance() {
    static AppPreferencesManager instance;
    return instance;
}
 
wxColour AppPreferencesManager::GetAccentColor() {
    const auto &prefs = GetInstance().GetPreferences();
    const auto &color = prefs.GetWindowSettings().accentColor;
    return wxColour(color.r, color.g, color.b);
}
 
} // namespace EmberForge