PreferencesDialog.cpp

Go to the documentation of this file.

#include "Dialogs/PreferencesDialog.h"
#include "App/MainFrame.h"
#include "Components/TabFactory.h"
#include "Dialogs/ParserConfigDialog.h"
#include "Utils/AppPreferences.h"
#include "Utils/Logger.h"
#include <cmath>
#include <functional>
#include <wx/sizer.h>
#include <wx/statbox.h>
#include <wx/statline.h>
#include <wx/stattext.h>
 
wxBEGIN_EVENT_TABLE(PreferencesDialog, EmberUI::ScalableDialog)
    EVT_TREE_SEL_CHANGED(ID_SECTION_TREE, PreferencesDialog::OnSectionSelected)
        EVT_BUTTON(wxID_OK, PreferencesDialog::OnOK) EVT_BUTTON(wxID_CANCEL, PreferencesDialog::OnCancel)
            EVT_BUTTON(ID_APPLY, PreferencesDialog::OnApply)
                EVT_BUTTON(ID_RESTORE_DEFAULTS, PreferencesDialog::OnRestoreDefaults)
                    EVT_BUTTON(ID_CONFIGURE_PARSER, PreferencesDialog::OnConfigureParser)
                        EVT_SLIDER(ID_DEFAULT_ZOOM, PreferencesDialog::OnZoomSliderChanged) // Update zoom label
    EVT_SLIDER(ID_ZOOM_STEP_SIZE, PreferencesDialog::OnZoomSliderChanged)                   // Update zoom step label
    EVT_SLIDER(ID_SELECTED_NODE_BG_TINT, PreferencesDialog::OnZoomSliderChanged)            // Update tint label
    EVT_SLIDER(ID_HOVERED_NODE_BG_TINT, PreferencesDialog::OnZoomSliderChanged)             // Update tint label
    EVT_SLIDER(ID_MOUSE_WHEEL_SENSITIVITY,
               PreferencesDialog::OnMouseWheelSensitivityChanged)              // Update sensitivity label
    EVT_SLIDER(ID_PAN_SENSITIVITY, PreferencesDialog::OnPanSensitivityChanged) // Update pan sensitivity label
    EVT_SLIDER(ID_PAN_SMOOTHNESS, PreferencesDialog::OnPanSmoothnessChanged)   // Update pan smoothness label
    EVT_SLIDER(ID_PAN_STEP_SIZE, PreferencesDialog::OnPanStepSizeChanged)      // Update pan step size label
    EVT_CHECKBOX(ID_MAX_WINDOW_UNLIMITED,
                 PreferencesDialog::OnMaxWindowUnlimitedChanged) // Enable/disable max size controls
    EVT_CHECKBOX(ID_MAX_SCENES_UNLIMITED,
                 PreferencesDialog::OnMaxScenesUnlimitedChanged) // Enable/disable max scenes control
    EVT_CHECKBOX(ID_BOTTOM_PANEL_HEIGHT_ENABLED, PreferencesDialog::OnBottomPanelHeightEnabledChanged)
        EVT_CHECKBOX(ID_BOTTOM_PANEL_MIN_HEIGHT_ENABLED, PreferencesDialog::OnBottomPanelMinHeightEnabledChanged)
            EVT_CHECKBOX(ID_LEFT_PANEL_WIDTH_ENABLED, PreferencesDialog::OnLeftPanelWidthEnabledChanged)
                EVT_CHECKBOX(ID_LEFT_PANEL_MIN_WIDTH_ENABLED, PreferencesDialog::OnLeftPanelMinWidthEnabledChanged)
                    EVT_CHECKBOX(ID_RIGHT_PANEL_WIDTH_ENABLED, PreferencesDialog::OnRightPanelWidthEnabledChanged)
                        EVT_CHECKBOX(ID_RIGHT_PANEL_MIN_WIDTH_ENABLED,
                                     PreferencesDialog::OnRightPanelMinWidthEnabledChanged) wxEND_EVENT_TABLE()
 
    // Custom tree item data to store panel pointer
    class SectionTreeItemData : public wxTreeItemData {
  public:
    SectionTreeItemData(wxPanel *panel) : m_panel(panel) {}
    wxPanel *GetPanel() const { return m_panel; }
 
  private:
    wxPanel *m_panel;
};
 
PreferencesDialog::PreferencesDialog(wxWindow *parent)
    : EmberUI::ScalableDialog(parent, wxID_ANY, "EmberForge Preferences", wxSize(1600, 1000)), m_splitter(nullptr),
      m_sectionTree(nullptr), m_settingsPanel(nullptr), m_windowPanel(nullptr), m_mainPanelPanel(nullptr),
      m_behaviorTreeViewPanel(nullptr), m_bottomPanelPanel(nullptr), m_fileExplorerPanel(nullptr),
      m_sidePanelPanel(nullptr), m_parserPanel(nullptr), m_panUpHotkeyTextCtrl(nullptr),
      m_panUpHotkeyCaptureButton(nullptr), m_panDownHotkeyTextCtrl(nullptr), m_panDownHotkeyCaptureButton(nullptr),
      m_panLeftHotkeyTextCtrl(nullptr), m_panLeftHotkeyCaptureButton(nullptr), m_panRightHotkeyTextCtrl(nullptr),
      m_panRightHotkeyCaptureButton(nullptr),
      // Initialize debug text controls to nullptr (order must match declaration)
      m_showCoordinateInfo(nullptr), m_coordinateInfoFontSize(nullptr), m_coordinateInfoColorPicker(nullptr),
      m_coordinateInfoAnchor(nullptr), m_coordinateInfoX(nullptr), m_coordinateInfoY(nullptr),
      m_showSelectedNodeInfo(nullptr), m_selectedNodeInfoFontSize(nullptr), m_selectedNodeDebugInfoColorPicker(nullptr),
      m_selectedNodeInfoAnchor(nullptr), m_selectedNodeInfoX(nullptr), m_selectedNodeInfoY(nullptr),
      m_showTreeInfo(nullptr), m_treeInfoFontSize(nullptr), m_treeInfoColorPicker(nullptr), m_treeInfoAnchor(nullptr),
      m_treeInfoX(nullptr), m_treeInfoY(nullptr), m_showControlsHelp(nullptr), m_controlsHelpFontSize(nullptr),
      m_controlsHelpColorPicker(nullptr), m_controlsHelpAnchor(nullptr), m_controlsHelpX(nullptr),
      m_controlsHelpY(nullptr), m_capturingTextCtrl(nullptr) {
    SetMinSize(wxSize(1400, 900));
    CreateLayout();
    LoadCurrentSettings();
 
    // Bind dialog-level mouse events for capturing mouse buttons anywhere in the dialog
    Bind(wxEVT_LEFT_DOWN, &PreferencesDialog::OnDialogMouseDown, this);
    Bind(wxEVT_MIDDLE_DOWN, &PreferencesDialog::OnDialogMouseDown, this);
    Bind(wxEVT_RIGHT_DOWN, &PreferencesDialog::OnDialogMouseDown, this);
 
    // Select first item in tree by default
    wxTreeItemId rootId = m_sectionTree->GetRootItem();
    if (rootId.IsOk()) {
        wxTreeItemIdValue cookie;
        wxTreeItemId firstItem = m_sectionTree->GetFirstChild(rootId, cookie);
        if (firstItem.IsOk()) {
            m_sectionTree->SelectItem(firstItem);
        }
    }
 
    // Bind mousewheel event to all spin controls to prevent accidental value changes while scrolling
    auto preventScrollWhenUnfocused = [](wxMouseEvent &event) {
        wxSpinCtrl *spin = dynamic_cast<wxSpinCtrl *>(event.GetEventObject());
        if (spin && spin->HasFocus()) {
            event.Skip(); // Allow scroll wheel when focused
        }
        // Otherwise consume the event (don't skip) to prevent value changes
    };
 
    // Bind to all spin controls
    if (m_minWindowWidth)
        m_minWindowWidth->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_minWindowHeight)
        m_minWindowHeight->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_maxWindowWidth)
        m_maxWindowWidth->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_maxWindowHeight)
        m_maxWindowHeight->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_gridSize)
        m_gridSize->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_coordinateInfoFontSize)
        m_coordinateInfoFontSize->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_coordinateInfoX)
        m_coordinateInfoX->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_coordinateInfoY)
        m_coordinateInfoY->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_selectedNodeInfoFontSize)
        m_selectedNodeInfoFontSize->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_selectedNodeInfoX)
        m_selectedNodeInfoX->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_selectedNodeInfoY)
        m_selectedNodeInfoY->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_treeInfoFontSize)
        m_treeInfoFontSize->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_treeInfoX)
        m_treeInfoX->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_treeInfoY)
        m_treeInfoY->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_controlsHelpFontSize)
        m_controlsHelpFontSize->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_controlsHelpX)
        m_controlsHelpX->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_controlsHelpY)
        m_controlsHelpY->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_maxScenes)
        m_maxScenes->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_bottomPanelHeight)
        m_bottomPanelHeight->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
    if (m_bottomPanelMinHeight)
        m_bottomPanelMinHeight->Bind(wxEVT_MOUSEWHEEL, preventScrollWhenUnfocused);
 
    // Make the settings panel and section panels steal focus when clicked
    // This ensures spin controls lose focus when clicking on empty space
    auto stealFocusOnClick = [this](wxMouseEvent &event) {
        // Transfer focus to the section tree to remove focus from spin controls
        if (m_sectionTree) {
            m_sectionTree->SetFocus();
        }
        event.Skip();
    };
 
    // Bind click handlers to the settings panel and all section panels
    if (m_settingsPanel) {
        m_settingsPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    }
    if (m_windowPanel)
        m_windowPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_mainPanelPanel)
        m_mainPanelPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_behaviorTreeViewPanel)
        m_behaviorTreeViewPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_bottomPanelPanel)
        m_bottomPanelPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_fileExplorerPanel)
        m_fileExplorerPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_logTabPanel)
        m_logTabPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_sidePanelPanel)
        m_sidePanelPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_leftPanelPanel)
        m_leftPanelPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_rightPanelPanel)
        m_rightPanelPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_tabsSubPanel)
        m_tabsSubPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_parserPanel)
        m_parserPanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
    if (m_performancePanel)
        m_performancePanel->Bind(wxEVT_LEFT_DOWN, stealFocusOnClick);
 
    LOG_INFO("UI", "Preferences dialog created");
}
 
void PreferencesDialog::CreateLayout() {
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Create splitter window
    m_splitter = new wxSplitterWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_3D | wxSP_LIVE_UPDATE);
    m_splitter->SetMinimumPaneSize(120);
    m_splitter->SetSashGravity(0.15); // 15% for section list, 85% for settings
 
    // Create left panel for section tree
    wxPanel *leftPanel = new wxPanel(m_splitter, wxID_ANY);
    leftPanel->SetBackgroundColour(wxColour(45, 45, 45));
    wxBoxSizer *leftSizer = new wxBoxSizer(wxVERTICAL);
 
    // Section tree
    m_sectionTree = new wxTreeCtrl(leftPanel, ID_SECTION_TREE, wxDefaultPosition, wxDefaultSize,
                                   wxTR_DEFAULT_STYLE | wxTR_HIDE_ROOT | wxTR_NO_LINES);
    m_sectionTree->SetBackgroundColour(wxColour(45, 45, 45));
    m_sectionTree->SetForegroundColour(wxColour(200, 200, 200));
 
    leftSizer->Add(m_sectionTree, 1, wxEXPAND | wxALL, 5);
    leftPanel->SetSizer(leftSizer);
 
    // Create right panel for settings
    wxPanel *rightPanel = new wxPanel(m_splitter, wxID_ANY);
    rightPanel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *rightSizer = new wxBoxSizer(wxVERTICAL);
 
    // Settings scrolled window
    m_settingsPanel = new wxScrolledWindow(rightPanel, wxID_ANY);
    m_settingsPanel->SetBackgroundColour(wxColour(50, 50, 50));
    m_settingsPanel->SetScrollRate(0, 10);
 
    m_settingsSizer = new wxBoxSizer(wxVERTICAL);
 
    // Create all section panels
    CreateSettingsPanels();
 
    m_settingsPanel->SetSizer(m_settingsSizer);
    rightSizer->Add(m_settingsPanel, 1, wxEXPAND | wxALL, 10);
 
    rightPanel->SetSizer(rightSizer);
 
    // Split the window
    m_splitter->SplitVertically(leftPanel, rightPanel, 150);
    mainSizer->Add(m_splitter, 1, wxEXPAND | wxALL, 0);
 
    // Button sizer at bottom
    wxBoxSizer *buttonSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_restoreDefaultsButton = new wxButton(this, ID_RESTORE_DEFAULTS, "Restore Defaults");
    m_restoreDefaultsButton->SetToolTip("Reset all settings to their default values");
 
    buttonSizer->Add(m_restoreDefaultsButton, 0, wxALL, 5);
    buttonSizer->AddStretchSpacer();
 
    m_applyButton = new wxButton(this, ID_APPLY, "Apply");
    m_applyButton->SetToolTip("Apply changes without closing the dialog");
 
    m_cancelButton = new wxButton(this, wxID_CANCEL, "Cancel");
    m_okButton = new wxButton(this, wxID_OK, "OK");
    m_okButton->SetDefault();
 
    buttonSizer->Add(m_applyButton, 0, wxALL, 5);
    buttonSizer->Add(m_cancelButton, 0, wxALL, 5);
    buttonSizer->Add(m_okButton, 0, wxALL, 5);
 
    mainSizer->Add(buttonSizer, 0, wxEXPAND | wxALL, 10);
 
    SetSizer(mainSizer);
    Layout();
}
 
void PreferencesDialog::CreateSettingsPanels() {
    // Create all section panels (hidden initially)
    m_windowPanel = CreateWindowSettings(m_settingsPanel);
    m_mainPanelPanel = CreateMainPanelSettings(m_settingsPanel);
    m_behaviorTreeViewPanel = CreateBehaviorTreeViewSettings(m_settingsPanel);
    m_bottomPanelPanel = CreateBottomPanelSettings(m_settingsPanel);
    m_fileExplorerPanel = CreateFileExplorerTabSettings(m_settingsPanel);
    m_logTabPanel = CreateLogTabSettings(m_settingsPanel);
    m_sidePanelPanel = CreateSidePanelSettings(m_settingsPanel);
    m_leftPanelPanel = CreateLeftPanelSettings(m_settingsPanel);
    m_rightPanelPanel = CreateRightPanelSettings(m_settingsPanel);
    m_tabsSubPanel = CreateTabsSubSettings(m_settingsPanel);
    m_parserPanel = CreateParserSettings(m_settingsPanel);
    m_performancePanel = CreatePerformanceSettings(m_settingsPanel);
 
    // Add to sizer (all will be shown/hidden dynamically)
    m_settingsSizer->Add(m_windowPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_mainPanelPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_behaviorTreeViewPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_bottomPanelPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_fileExplorerPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_logTabPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_sidePanelPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_leftPanelPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_rightPanelPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_tabsSubPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_parserPanel, 1, wxEXPAND | wxALL, 5);
    m_settingsSizer->Add(m_performancePanel, 1, wxEXPAND | wxALL, 5);
 
    // Hide all panels initially
    m_windowPanel->Hide();
    m_mainPanelPanel->Hide();
    m_behaviorTreeViewPanel->Hide();
    m_bottomPanelPanel->Hide();
    m_fileExplorerPanel->Hide();
    m_logTabPanel->Hide();
    m_sidePanelPanel->Hide();
    m_leftPanelPanel->Hide();
    m_rightPanelPanel->Hide();
    m_tabsSubPanel->Hide();
    m_parserPanel->Hide();
    m_performancePanel->Hide();
 
    // Build tree structure after panels are created
    wxTreeItemId root = m_sectionTree->AddRoot("Preferences");
 
    // Window section
    wxTreeItemId windowItem = m_sectionTree->AppendItem(root, "Window");
    m_sectionTree->SetItemData(windowItem, new SectionTreeItemData(m_windowPanel));
 
    // Main Panel section with child
    wxTreeItemId mainPanelItem = m_sectionTree->AppendItem(root, "Main Panel");
    m_sectionTree->SetItemData(mainPanelItem, new SectionTreeItemData(m_mainPanelPanel));
 
    wxTreeItemId behaviorTreeViewItem = m_sectionTree->AppendItem(mainPanelItem, "Behavior Tree View");
    m_sectionTree->SetItemData(behaviorTreeViewItem, new SectionTreeItemData(m_behaviorTreeViewPanel));
 
    // Expand Main Panel by default to show child
    m_sectionTree->Expand(mainPanelItem);
 
    // Side Panel section (parent for all panels that inherit from SidePanel)
    wxTreeItemId sidePanelItem = m_sectionTree->AppendItem(root, "Side Panel");
    m_sectionTree->SetItemData(sidePanelItem, new SectionTreeItemData(m_sidePanelPanel));
 
    // Left Panel under Side Panel
    wxTreeItemId leftPanelItem = m_sectionTree->AppendItem(sidePanelItem, "Left Panel");
    m_sectionTree->SetItemData(leftPanelItem, new SectionTreeItemData(m_leftPanelPanel));
 
    // Right Panel under Side Panel
    wxTreeItemId rightPanelItem = m_sectionTree->AppendItem(sidePanelItem, "Right Panel");
    m_sectionTree->SetItemData(rightPanelItem, new SectionTreeItemData(m_rightPanelPanel));
 
    // Bottom Panel under Side Panel
    wxTreeItemId bottomPanelItem = m_sectionTree->AppendItem(sidePanelItem, "Bottom Panel");
    m_sectionTree->SetItemData(bottomPanelItem, new SectionTreeItemData(m_bottomPanelPanel));
 
    // Expand Side Panel by default
    m_sectionTree->Expand(sidePanelItem);
 
    // Tabs section (top-level)
    wxTreeItemId tabsItem = m_sectionTree->AppendItem(root, "Tabs");
    m_sectionTree->SetItemData(tabsItem, new SectionTreeItemData(m_tabsSubPanel));
 
    // File Explorer Tab under Tabs
    wxTreeItemId fileExplorerItem = m_sectionTree->AppendItem(tabsItem, "File Explorer Tab");
    m_sectionTree->SetItemData(fileExplorerItem, new SectionTreeItemData(m_fileExplorerPanel));
 
    // Log Tab under Tabs
    wxTreeItemId logTabItem = m_sectionTree->AppendItem(tabsItem, "Log Tab");
    m_sectionTree->SetItemData(logTabItem, new SectionTreeItemData(m_logTabPanel));
 
    // Expand Tabs by default
    m_sectionTree->Expand(tabsItem);
 
    // Parser section
    wxTreeItemId parserItem = m_sectionTree->AppendItem(root, "Parser");
    m_sectionTree->SetItemData(parserItem, new SectionTreeItemData(m_parserPanel));
 
    // Performance section
    wxTreeItemId performanceItem = m_sectionTree->AppendItem(root, "Performance");
    m_sectionTree->SetItemData(performanceItem, new SectionTreeItemData(m_performancePanel));
}
 
wxPanel *PreferencesDialog::CreateWindowSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // Appearance group
    wxStaticBoxSizer *appearanceGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Appearance");
 
    // Theme choice
    wxBoxSizer *themeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *themeLabel = new wxStaticText(panel, wxID_ANY, "Theme:");
    themeLabel->SetForegroundColour(wxColour(200, 200, 200));
    themeSizer->Add(themeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString themes;
    themes.Add("Dark");
    themes.Add("Light (Not Implemented)");
    m_themeChoice = new wxChoice(panel, ID_THEME_CHOICE, wxDefaultPosition, wxDefaultSize, themes);
    themeSizer->Add(m_themeChoice, 1, wxEXPAND);
    appearanceGroup->Add(themeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Accent color
    wxBoxSizer *accentSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *accentLabel = new wxStaticText(panel, wxID_ANY, "Accent Color:");
    accentLabel->SetForegroundColour(wxColour(200, 200, 200));
    accentSizer->Add(accentLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_accentColorPicker = new wxColourPickerCtrl(panel, ID_ACCENT_COLOR);
    accentSizer->Add(m_accentColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    appearanceGroup->Add(accentSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(appearanceGroup, 0, wxEXPAND | wxALL, 5);
 
    // Startup group
    wxStaticBoxSizer *startupGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Startup");
 
    wxBoxSizer *startupModeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *startupModeLabel = new wxStaticText(panel, wxID_ANY, "Window mode on startup:");
    startupModeLabel->SetForegroundColour(wxColour(200, 200, 200));
    startupModeSizer->Add(startupModeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString startupModes;
    startupModes.Add("Normal");
    startupModes.Add("Maximized");
    m_startupModeChoice = new wxChoice(panel, ID_STARTUP_MODE, wxDefaultPosition, wxDefaultSize, startupModes);
    startupModeSizer->Add(m_startupModeChoice, 1, wxEXPAND);
    startupGroup->Add(startupModeSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(startupGroup, 0, wxEXPAND | wxALL, 5);
 
    // File Menu Hotkeys group
    wxStaticBoxSizer *fileHotkeysGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "File Menu Hotkeys");
 
    // Helper lambda to create hotkey row
    auto createHotkeyRow = [&](const wxString &labelText, wxTextCtrl *&textCtrl, wxButton *&captureBtn) {
        wxBoxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
        wxStaticText *label = new wxStaticText(panel, wxID_ANY, labelText, wxDefaultPosition, wxSize(120, -1));
        label->SetForegroundColour(wxColour(200, 200, 200));
        sizer->Add(label, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
        textCtrl = new wxTextCtrl(panel, wxID_ANY, "", wxDefaultPosition, wxSize(150, -1), wxTE_READONLY);
        textCtrl->SetBackgroundColour(wxColour(60, 60, 60));
        textCtrl->SetForegroundColour(wxColour(200, 200, 200));
        textCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
        textCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
        sizer->Add(textCtrl, 1, wxEXPAND);
 
        captureBtn = new wxButton(panel, wxID_ANY, "Capture", wxDefaultPosition, wxSize(80, -1));
        captureBtn->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
        sizer->Add(captureBtn, 0, wxLEFT, 5);
 
        return sizer;
    };
 
    fileHotkeysGroup->Add(createHotkeyRow("New Project:", m_newProjectHotkeyTextCtrl, m_newProjectHotkeyCaptureButton),
                          0, wxEXPAND | wxALL, 3);
    fileHotkeysGroup->Add(
        createHotkeyRow("Open Project:", m_openProjectHotkeyTextCtrl, m_openProjectHotkeyCaptureButton), 0,
        wxEXPAND | wxALL, 3);
    fileHotkeysGroup->Add(createHotkeyRow("Open File:", m_openFileHotkeyTextCtrl, m_openFileHotkeyCaptureButton), 0,
                          wxEXPAND | wxALL, 3);
    fileHotkeysGroup->Add(createHotkeyRow("Save:", m_saveHotkeyTextCtrl, m_saveHotkeyCaptureButton), 0,
                          wxEXPAND | wxALL, 3);
    fileHotkeysGroup->Add(createHotkeyRow("Save As:", m_saveAsHotkeyTextCtrl, m_saveAsHotkeyCaptureButton), 0,
                          wxEXPAND | wxALL, 3);
 
    panelSizer->Add(fileHotkeysGroup, 0, wxEXPAND | wxALL, 5);
 
    // View Menu Hotkeys group
    wxStaticBoxSizer *viewHotkeysGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "View Menu Hotkeys");
    viewHotkeysGroup->Add(createHotkeyRow("Maximize:", m_maximizeHotkeyTextCtrl, m_maximizeHotkeyCaptureButton), 0,
                          wxEXPAND | wxALL, 3);
    viewHotkeysGroup->Add(createHotkeyRow("Reset UI:", m_resetUIHotkeyTextCtrl, m_resetUIHotkeyCaptureButton), 0,
                          wxEXPAND | wxALL, 3);
 
    panelSizer->Add(viewHotkeysGroup, 0, wxEXPAND | wxALL, 5);
 
    // Settings Menu Hotkeys group
    wxStaticBoxSizer *settingsHotkeysGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Settings Menu Hotkeys");
    settingsHotkeysGroup->Add(
        createHotkeyRow("Preferences:", m_preferencesHotkeyTextCtrl, m_preferencesHotkeyCaptureButton), 0,
        wxEXPAND | wxALL, 3);
    settingsHotkeysGroup->Add(
        createHotkeyRow("Parser Config:", m_parserConfigHotkeyTextCtrl, m_parserConfigHotkeyCaptureButton), 0,
        wxEXPAND | wxALL, 3);
 
    panelSizer->Add(settingsHotkeysGroup, 0, wxEXPAND | wxALL, 5);
 
    // Window Appearance group
    wxStaticBoxSizer *windowAppearanceGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Window Appearance");
 
    // Show status bar
    m_showStatusBar = new wxCheckBox(panel, ID_SHOW_STATUS_BAR, "Show status bar at bottom");
    m_showStatusBar->SetForegroundColour(wxColour(200, 200, 200));
    m_showStatusBar->SetToolTip("Display the status bar at the bottom of the window");
    windowAppearanceGroup->Add(m_showStatusBar, 0, wxALL, 5);
 
    // Show panel captions
    m_showPanelCaptions = new wxCheckBox(panel, ID_SHOW_PANEL_CAPTIONS, "Show panel caption headers");
    m_showPanelCaptions->SetForegroundColour(wxColour(200, 200, 200));
    m_showPanelCaptions->SetToolTip("Display caption headers above panels (Left Panel, Right Panel, etc.)");
    windowAppearanceGroup->Add(m_showPanelCaptions, 0, wxALL, 5);
 
    // Always on top
    m_alwaysOnTop = new wxCheckBox(panel, ID_ALWAYS_ON_TOP, "Always on top");
    m_alwaysOnTop->SetForegroundColour(wxColour(200, 200, 200));
    m_alwaysOnTop->SetToolTip("Keep window above all other windows");
    windowAppearanceGroup->Add(m_alwaysOnTop, 0, wxALL, 5);
 
    panelSizer->Add(windowAppearanceGroup, 0, wxEXPAND | wxALL, 5);
 
    // Window Constraints group
    wxStaticBoxSizer *constraintsGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Window Constraints");
 
    // Minimum size
    wxStaticText *minSizeLabel = new wxStaticText(panel, wxID_ANY, "Minimum Window Size (% of screen):");
    minSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    constraintsGroup->Add(minSizeLabel, 0, wxALL, 5);
 
    wxBoxSizer *minSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *minWidthLabel = new wxStaticText(panel, wxID_ANY, "Width %:");
    minWidthLabel->SetForegroundColour(wxColour(200, 200, 200));
    minSizeSizer->Add(minWidthLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_minWindowWidth = new wxSpinCtrl(panel, ID_MIN_WINDOW_WIDTH, "42", wxDefaultPosition, wxSize(120, -1),
                                      wxSP_ARROW_KEYS, 10, 100, 42);
    minSizeSizer->Add(m_minWindowWidth, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxStaticText *minHeightLabel = new wxStaticText(panel, wxID_ANY, "Height %:");
    minHeightLabel->SetForegroundColour(wxColour(200, 200, 200));
    minSizeSizer->Add(minHeightLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_minWindowHeight = new wxSpinCtrl(panel, ID_MIN_WINDOW_HEIGHT, "56", wxDefaultPosition, wxSize(120, -1),
                                       wxSP_ARROW_KEYS, 10, 100, 56);
    minSizeSizer->Add(m_minWindowHeight, 0);
 
    constraintsGroup->Add(minSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Maximum size
    wxStaticText *maxSizeLabel = new wxStaticText(panel, wxID_ANY, "Maximum Window Size (% of screen):");
    maxSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    constraintsGroup->Add(maxSizeLabel, 0, wxALL, 5);
 
    m_maxWindowUnlimited = new wxCheckBox(panel, ID_MAX_WINDOW_UNLIMITED, "Unlimited (no maximum size)");
    m_maxWindowUnlimited->SetForegroundColour(wxColour(200, 200, 200));
    constraintsGroup->Add(m_maxWindowUnlimited, 0, wxALL, 5);
 
    wxBoxSizer *maxSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *maxWidthLabel = new wxStaticText(panel, wxID_ANY, "Width %:");
    maxWidthLabel->SetForegroundColour(wxColour(200, 200, 200));
    maxSizeSizer->Add(maxWidthLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_maxWindowWidth = new wxSpinCtrl(panel, ID_MAX_WINDOW_WIDTH, "-1", wxDefaultPosition, wxSize(120, -1),
                                      wxSP_ARROW_KEYS, -1, 100, -1);
    maxSizeSizer->Add(m_maxWindowWidth, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxStaticText *maxHeightLabel = new wxStaticText(panel, wxID_ANY, "Height %:");
    maxHeightLabel->SetForegroundColour(wxColour(200, 200, 200));
    maxSizeSizer->Add(maxHeightLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_maxWindowHeight = new wxSpinCtrl(panel, ID_MAX_WINDOW_HEIGHT, "-1", wxDefaultPosition, wxSize(120, -1),
                                       wxSP_ARROW_KEYS, -1, 100, -1);
    maxSizeSizer->Add(m_maxWindowHeight, 0);
 
    constraintsGroup->Add(maxSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Aspect ratio
    m_enforceAspectRatio = new wxCheckBox(panel, ID_ENFORCE_ASPECT_RATIO, "Enforce aspect ratio");
    m_enforceAspectRatio->SetForegroundColour(wxColour(200, 200, 200));
    m_enforceAspectRatio->SetToolTip("Maintain window width/height ratio when resizing");
    constraintsGroup->Add(m_enforceAspectRatio, 0, wxALL, 5);
 
    wxBoxSizer *aspectRatioSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *aspectLabel = new wxStaticText(panel, wxID_ANY, "Aspect Ratio:");
    aspectLabel->SetForegroundColour(wxColour(200, 200, 200));
    aspectRatioSizer->Add(aspectLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_aspectRatioWidth = new wxTextCtrl(panel, ID_ASPECT_RATIO_WIDTH, "16", wxDefaultPosition, wxSize(50, -1));
    aspectRatioSizer->Add(m_aspectRatioWidth, 0, wxRIGHT, 5);
 
    wxStaticText *aspectColon = new wxStaticText(panel, wxID_ANY, ":");
    aspectColon->SetForegroundColour(wxColour(200, 200, 200));
    aspectRatioSizer->Add(aspectColon, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_aspectRatioHeight = new wxTextCtrl(panel, ID_ASPECT_RATIO_HEIGHT, "9", wxDefaultPosition, wxSize(50, -1));
    aspectRatioSizer->Add(m_aspectRatioHeight, 0);
 
    wxStaticText *aspectNote = new wxStaticText(panel, wxID_ANY, "(e.g., 16:9, 4:3, 21:9)");
    aspectNote->SetForegroundColour(wxColour(150, 150, 150));
    aspectRatioSizer->Add(aspectNote, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 10);
 
    constraintsGroup->Add(aspectRatioSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(constraintsGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateMainPanelSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // Canvas group
    wxStaticBoxSizer *canvasGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Canvas");
 
    wxBoxSizer *bgColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *bgColorLabel = new wxStaticText(panel, wxID_ANY, "Background Color:");
    bgColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    bgColorSizer->Add(bgColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_canvasBackgroundPicker = new wxColourPickerCtrl(panel, ID_CANVAS_BACKGROUND);
    bgColorSizer->Add(m_canvasBackgroundPicker, 0, wxALIGN_CENTER_VERTICAL);
    canvasGroup->Add(bgColorSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(canvasGroup, 0, wxEXPAND | wxALL, 5);
 
    // Scene Management group
    wxStaticBoxSizer *sceneManagementGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Scene Management");
 
    wxBoxSizer *maxScenesSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *maxScenesLabel = new wxStaticText(panel, wxID_ANY, "Maximum Scenes:");
    maxScenesLabel->SetForegroundColour(wxColour(200, 200, 200));
    maxScenesSizer->Add(maxScenesLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_maxScenes =
        new wxSpinCtrl(panel, ID_MAX_SCENES, "10", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 1, 50, 10);
    maxScenesSizer->Add(m_maxScenes, 0, wxALIGN_CENTER_VERTICAL);
 
    m_maxScenesUnlimited = new wxCheckBox(panel, ID_MAX_SCENES_UNLIMITED, "Unlimited");
    m_maxScenesUnlimited->SetForegroundColour(wxColour(200, 200, 200));
    maxScenesSizer->Add(m_maxScenesUnlimited, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 40);
 
    sceneManagementGroup->Add(maxScenesSizer, 0, wxEXPAND | wxALL, 5);
 
    wxStaticText *sceneNote =
        new wxStaticText(panel, wxID_ANY, "Limit the number of behavior tree scenes that can be open simultaneously");
    sceneNote->SetForegroundColour(wxColour(150, 150, 150));
    sceneNote->Wrap(450);
    sceneManagementGroup->Add(sceneNote, 0, wxALL, 5);
 
    // Close confirmation
    wxBoxSizer *closeConfirmSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *closeConfirmLabel = new wxStaticText(panel, wxID_ANY, "Close Confirmation:");
    closeConfirmLabel->SetForegroundColour(wxColour(200, 200, 200));
    closeConfirmSizer->Add(closeConfirmLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString closeConfirmOptions;
    closeConfirmOptions.Add("Always Ask");
    closeConfirmOptions.Add("Never Ask");
    closeConfirmOptions.Add("Ask If Unsaved");
    m_closeConfirmation =
        new wxChoice(panel, ID_CLOSE_CONFIRMATION, wxDefaultPosition, wxDefaultSize, closeConfirmOptions);
    closeConfirmSizer->Add(m_closeConfirmation, 1, wxEXPAND);
 
    sceneManagementGroup->Add(closeConfirmSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(sceneManagementGroup, 0, wxEXPAND | wxALL, 5);
 
    // Tab Switching Hotkeys group
    wxStaticBoxSizer *tabSwitchingGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Tab Switching");
 
    // Next scene hotkey
    wxBoxSizer *nextSceneHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *nextSceneLabel = new wxStaticText(panel, wxID_ANY, "Next Scene:");
    nextSceneLabel->SetForegroundColour(wxColour(200, 200, 200));
    nextSceneHotkeySizer->Add(nextSceneLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_nextSceneHotkeyTextCtrl = new wxTextCtrl(panel, wxID_ANY, "", wxDefaultPosition, wxSize(150, -1), wxTE_READONLY);
    m_nextSceneHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_nextSceneHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_nextSceneHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_nextSceneHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    nextSceneHotkeySizer->Add(m_nextSceneHotkeyTextCtrl, 1, wxEXPAND);
 
    m_nextSceneHotkeyCaptureButton = new wxButton(panel, wxID_ANY, "Capture", wxDefaultPosition, wxSize(80, -1));
    m_nextSceneHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    nextSceneHotkeySizer->Add(m_nextSceneHotkeyCaptureButton, 0, wxLEFT, 5);
 
    tabSwitchingGroup->Add(nextSceneHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    // Previous scene hotkey
    wxBoxSizer *previousSceneHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *previousSceneLabel = new wxStaticText(panel, wxID_ANY, "Previous Scene:");
    previousSceneLabel->SetForegroundColour(wxColour(200, 200, 200));
    previousSceneHotkeySizer->Add(previousSceneLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_previousSceneHotkeyTextCtrl =
        new wxTextCtrl(panel, wxID_ANY, "", wxDefaultPosition, wxSize(150, -1), wxTE_READONLY);
    m_previousSceneHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_previousSceneHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_previousSceneHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_previousSceneHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    previousSceneHotkeySizer->Add(m_previousSceneHotkeyTextCtrl, 1, wxEXPAND);
 
    m_previousSceneHotkeyCaptureButton = new wxButton(panel, wxID_ANY, "Capture", wxDefaultPosition, wxSize(80, -1));
    m_previousSceneHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    previousSceneHotkeySizer->Add(m_previousSceneHotkeyCaptureButton, 0, wxLEFT, 5);
 
    tabSwitchingGroup->Add(previousSceneHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(tabSwitchingGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateBehaviorTreeViewSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // Zoom group
    wxStaticBoxSizer *zoomGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Zoom & View");
 
    // Default zoom slider
    wxBoxSizer *zoomSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *zoomLabelText = new wxStaticText(panel, wxID_ANY, "Default Zoom:");
    zoomLabelText->SetForegroundColour(wxColour(200, 200, 200));
    zoomSizer->Add(zoomLabelText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_defaultZoomSlider =
        new wxSlider(panel, ID_DEFAULT_ZOOM, 100, 10, 200, wxDefaultPosition, wxSize(200, -1), wxSL_HORIZONTAL);
    m_defaultZoomSlider->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    zoomSizer->Add(m_defaultZoomSlider, 1, wxEXPAND | wxRIGHT, 10);
 
    m_zoomLabel = new wxStaticText(panel, wxID_ANY, "100%");
    m_zoomLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_zoomLabel->SetMinSize(wxSize(50, -1));
    zoomSizer->Add(m_zoomLabel, 0, wxALIGN_CENTER_VERTICAL);
 
    zoomGroup->Add(zoomSizer, 0, wxEXPAND | wxALL, 5);
 
    // Zoom step size
    wxBoxSizer *zoomStepSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *zoomStepLabel = new wxStaticText(panel, wxID_ANY, "Zoom step size:");
    zoomStepLabel->SetForegroundColour(wxColour(200, 200, 200));
    zoomStepSizer->Add(zoomStepLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_zoomStepSize =
        new wxSlider(panel, ID_ZOOM_STEP_SIZE, 10, 1, 50, wxDefaultPosition, wxSize(200, -1), wxSL_HORIZONTAL);
    m_zoomStepSize->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    zoomStepSizer->Add(m_zoomStepSize, 1, wxEXPAND | wxRIGHT, 10);
 
    m_zoomStepSizeLabel = new wxStaticText(panel, wxID_ANY, "10%");
    m_zoomStepSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_zoomStepSizeLabel->SetMinSize(wxSize(50, -1));
    zoomStepSizer->Add(m_zoomStepSizeLabel, 0, wxALIGN_CENTER_VERTICAL);
 
    zoomGroup->Add(zoomStepSizer, 0, wxEXPAND | wxALL, 5);
 
    // Mouse wheel sensitivity
    wxBoxSizer *wheelSensitivitySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *wheelSensitivityText = new wxStaticText(panel, wxID_ANY, "Mouse wheel sensitivity:");
    wheelSensitivityText->SetForegroundColour(wxColour(200, 200, 200));
    wheelSensitivitySizer->Add(wheelSensitivityText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_mouseWheelSensitivity = new wxSlider(panel, ID_MOUSE_WHEEL_SENSITIVITY, 100, 10, 500, wxDefaultPosition,
                                           wxSize(200, -1), wxSL_HORIZONTAL);
    m_mouseWheelSensitivity->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    wheelSensitivitySizer->Add(m_mouseWheelSensitivity, 1, wxEXPAND | wxRIGHT, 10);
 
    m_mouseWheelSensitivityLabel = new wxStaticText(panel, wxID_ANY, "1.0x");
    m_mouseWheelSensitivityLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_mouseWheelSensitivityLabel->SetMinSize(wxSize(50, -1));
    wheelSensitivitySizer->Add(m_mouseWheelSensitivityLabel, 0, wxALIGN_CENTER_VERTICAL);
    zoomGroup->Add(wheelSensitivitySizer, 0, wxEXPAND | wxALL, 5);
 
    // Zoom follows cursor
    m_zoomFollowsCursor = new wxCheckBox(panel, ID_ZOOM_FOLLOWS_CURSOR, "Zoom towards cursor position");
    m_zoomFollowsCursor->SetForegroundColour(wxColour(200, 200, 200));
    zoomGroup->Add(m_zoomFollowsCursor, 0, wxALL, 5);
 
    // Reset view hotkey (full reset: zoom + pan)
    wxBoxSizer *resetViewHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *resetViewHotkeyLabel = new wxStaticText(panel, wxID_ANY, "Reset view hotkey:");
    resetViewHotkeyLabel->SetForegroundColour(wxColour(200, 200, 200));
    resetViewHotkeySizer->Add(resetViewHotkeyLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_resetViewHotkeyTextCtrl = new wxTextCtrl(panel, ID_RESET_VIEW_HOTKEY_TEXT, "R", wxDefaultPosition,
                                               wxSize(150, -1), wxTE_READONLY | wxTE_CENTRE);
    m_resetViewHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_resetViewHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_resetViewHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_resetViewHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    resetViewHotkeySizer->Add(m_resetViewHotkeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_resetViewHotkeyCaptureButton = new wxButton(panel, ID_RESET_VIEW_HOTKEY_CAPTURE, "Capture");
    m_resetViewHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    resetViewHotkeySizer->Add(m_resetViewHotkeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    zoomGroup->Add(resetViewHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(zoomGroup, 0, wxEXPAND | wxALL, 5);
 
    // Pan group
    wxStaticBoxSizer *panGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Panning");
 
    // Pan sensitivity slider
    wxBoxSizer *panSensitivitySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panSensitivityText = new wxStaticText(panel, wxID_ANY, "Pan sensitivity:");
    panSensitivityText->SetForegroundColour(wxColour(200, 200, 200));
    panSensitivitySizer->Add(panSensitivityText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panSensitivity =
        new wxSlider(panel, ID_PAN_SENSITIVITY, 151, 10, 200, wxDefaultPosition, wxSize(200, -1), wxSL_HORIZONTAL);
    m_panSensitivity->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    panSensitivitySizer->Add(m_panSensitivity, 1, wxEXPAND | wxRIGHT, 10);
 
    m_panSensitivityLabel = new wxStaticText(panel, wxID_ANY, "1.51x");
    m_panSensitivityLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_panSensitivityLabel->SetMinSize(wxSize(50, -1));
    panSensitivitySizer->Add(m_panSensitivityLabel, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panSensitivitySizer, 0, wxEXPAND | wxALL, 5);
 
    // Pan smoothness slider
    wxBoxSizer *panSmoothnessSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panSmoothnessText = new wxStaticText(panel, wxID_ANY, "Pan smoothness:");
    panSmoothnessText->SetForegroundColour(wxColour(200, 200, 200));
    panSmoothnessSizer->Add(panSmoothnessText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panSmoothness =
        new wxSlider(panel, ID_PAN_SMOOTHNESS, 30, 0, 100, wxDefaultPosition, wxSize(200, -1), wxSL_HORIZONTAL);
    m_panSmoothness->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    m_panSmoothness->Bind(wxEVT_SLIDER, &PreferencesDialog::OnPanSmoothnessChanged, this);
    panSmoothnessSizer->Add(m_panSmoothness, 1, wxEXPAND | wxRIGHT, 10);
 
    m_panSmoothnessLabel = new wxStaticText(panel, wxID_ANY, "30%");
    m_panSmoothnessLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_panSmoothnessLabel->SetMinSize(wxSize(50, -1));
    panSmoothnessSizer->Add(m_panSmoothnessLabel, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panSmoothnessSizer, 0, wxEXPAND | wxALL, 5);
 
    // Pan step size slider
    wxBoxSizer *panStepSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panStepSizeText = new wxStaticText(panel, wxID_ANY, "Pan step size:");
    panStepSizeText->SetForegroundColour(wxColour(200, 200, 200));
    panStepSizeSizer->Add(panStepSizeText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panStepSize =
        new wxSlider(panel, ID_PAN_STEP_SIZE, 40, 10, 500, wxDefaultPosition, wxSize(200, -1), wxSL_HORIZONTAL);
    m_panStepSize->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    m_panStepSize->Bind(wxEVT_SLIDER, &PreferencesDialog::OnPanStepSizeChanged, this);
    panStepSizeSizer->Add(m_panStepSize, 1, wxEXPAND | wxRIGHT, 10);
 
    m_panStepSizeLabel = new wxStaticText(panel, wxID_ANY, "40px");
    m_panStepSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_panStepSizeLabel->SetMinSize(wxSize(50, -1));
    panStepSizeSizer->Add(m_panStepSizeLabel, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panStepSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Enable smooth panning checkbox
    m_enableSmoothPanning = new wxCheckBox(panel, ID_ENABLE_SMOOTH_PANNING, "Enable smooth panning (arrow keys)");
    m_enableSmoothPanning->SetForegroundColour(wxColour(200, 200, 200));
    panGroup->Add(m_enableSmoothPanning, 0, wxALL, 5);
 
    // Pan key (hold to pan)
    wxBoxSizer *panKeyHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panKeyHotkeyLabel = new wxStaticText(panel, wxID_ANY, "Pan key (hold + drag):");
    panKeyHotkeyLabel->SetForegroundColour(wxColour(200, 200, 200));
    panKeyHotkeySizer->Add(panKeyHotkeyLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panKeyTextCtrl = new wxTextCtrl(panel, ID_PAN_KEY_TEXT, "Middle Mouse Button", wxDefaultPosition, wxSize(150, -1),
                                      wxTE_READONLY | wxTE_CENTRE);
    m_panKeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_panKeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_panKeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_panKeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    // Mouse events are now handled at dialog level via OnDialogMouseDown
    panKeyHotkeySizer->Add(m_panKeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_panKeyCaptureButton = new wxButton(panel, ID_PAN_KEY_CAPTURE, "Capture");
    m_panKeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    panKeyHotkeySizer->Add(m_panKeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panKeyHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    // Pan up hotkey
    wxBoxSizer *panUpHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panUpLabel = new wxStaticText(panel, wxID_ANY, "Pan up:");
    panUpLabel->SetForegroundColour(wxColour(200, 200, 200));
    panUpHotkeySizer->Add(panUpLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panUpHotkeyTextCtrl = new wxTextCtrl(panel, ID_PAN_UP_HOTKEY_TEXT, "Up", wxDefaultPosition, wxSize(150, -1),
                                           wxTE_READONLY | wxTE_CENTRE);
    m_panUpHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_panUpHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_panUpHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_panUpHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    panUpHotkeySizer->Add(m_panUpHotkeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_panUpHotkeyCaptureButton = new wxButton(panel, ID_PAN_UP_HOTKEY_CAPTURE, "Capture");
    m_panUpHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    panUpHotkeySizer->Add(m_panUpHotkeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panUpHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    // Pan down hotkey
    wxBoxSizer *panDownHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panDownLabel = new wxStaticText(panel, wxID_ANY, "Pan down:");
    panDownLabel->SetForegroundColour(wxColour(200, 200, 200));
    panDownHotkeySizer->Add(panDownLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panDownHotkeyTextCtrl = new wxTextCtrl(panel, ID_PAN_DOWN_HOTKEY_TEXT, "Down", wxDefaultPosition, wxSize(150, -1),
                                             wxTE_READONLY | wxTE_CENTRE);
    m_panDownHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_panDownHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_panDownHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_panDownHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    panDownHotkeySizer->Add(m_panDownHotkeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_panDownHotkeyCaptureButton = new wxButton(panel, ID_PAN_DOWN_HOTKEY_CAPTURE, "Capture");
    m_panDownHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    panDownHotkeySizer->Add(m_panDownHotkeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panDownHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    // Pan left hotkey
    wxBoxSizer *panLeftHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panLeftLabel = new wxStaticText(panel, wxID_ANY, "Pan left:");
    panLeftLabel->SetForegroundColour(wxColour(200, 200, 200));
    panLeftHotkeySizer->Add(panLeftLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panLeftHotkeyTextCtrl = new wxTextCtrl(panel, ID_PAN_LEFT_HOTKEY_TEXT, "Left", wxDefaultPosition, wxSize(150, -1),
                                             wxTE_READONLY | wxTE_CENTRE);
    m_panLeftHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_panLeftHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_panLeftHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_panLeftHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    panLeftHotkeySizer->Add(m_panLeftHotkeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_panLeftHotkeyCaptureButton = new wxButton(panel, ID_PAN_LEFT_HOTKEY_CAPTURE, "Capture");
    m_panLeftHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    panLeftHotkeySizer->Add(m_panLeftHotkeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panLeftHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    // Pan right hotkey
    wxBoxSizer *panRightHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *panRightLabel = new wxStaticText(panel, wxID_ANY, "Pan right:");
    panRightLabel->SetForegroundColour(wxColour(200, 200, 200));
    panRightHotkeySizer->Add(panRightLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_panRightHotkeyTextCtrl = new wxTextCtrl(panel, ID_PAN_RIGHT_HOTKEY_TEXT, "Right", wxDefaultPosition,
                                              wxSize(150, -1), wxTE_READONLY | wxTE_CENTRE);
    m_panRightHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_panRightHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_panRightHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_panRightHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    panRightHotkeySizer->Add(m_panRightHotkeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_panRightHotkeyCaptureButton = new wxButton(panel, ID_PAN_RIGHT_HOTKEY_CAPTURE, "Capture");
    m_panRightHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    panRightHotkeySizer->Add(m_panRightHotkeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    panGroup->Add(panRightHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(panGroup, 0, wxEXPAND | wxALL, 5);
 
    // Action hotkeys group
    wxStaticBoxSizer *navGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Action Hotkeys");
 
    // Expand/Collapse hotkey (previously "Center on selected")
    wxBoxSizer *centerHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *centerHotkeyLabel = new wxStaticText(panel, wxID_ANY, "Expand/Collapse:");
    centerHotkeyLabel->SetForegroundColour(wxColour(200, 200, 200));
    centerHotkeySizer->Add(centerHotkeyLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_centerOnNodeHotkeyTextCtrl = new wxTextCtrl(panel, ID_CENTER_ON_NODE_HOTKEY_TEXT, "C", wxDefaultPosition,
                                                  wxSize(150, -1), wxTE_READONLY | wxTE_CENTRE);
    m_centerOnNodeHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_centerOnNodeHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_centerOnNodeHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_centerOnNodeHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    centerHotkeySizer->Add(m_centerOnNodeHotkeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_centerOnNodeHotkeyCaptureButton = new wxButton(panel, ID_CENTER_ON_NODE_HOTKEY_CAPTURE, "Capture");
    m_centerOnNodeHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    centerHotkeySizer->Add(m_centerOnNodeHotkeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    navGroup->Add(centerHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    // Delete node hotkey
    wxBoxSizer *deleteHotkeySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *deleteHotkeyLabel = new wxStaticText(panel, wxID_ANY, "Delete node:");
    deleteHotkeyLabel->SetForegroundColour(wxColour(200, 200, 200));
    deleteHotkeySizer->Add(deleteHotkeyLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_deleteNodeHotkeyTextCtrl = new wxTextCtrl(panel, ID_DELETE_NODE_HOTKEY_TEXT, "Delete", wxDefaultPosition,
                                                wxSize(150, -1), wxTE_READONLY | wxTE_CENTRE);
    m_deleteNodeHotkeyTextCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_deleteNodeHotkeyTextCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_deleteNodeHotkeyTextCtrl->Bind(wxEVT_KEY_DOWN, &PreferencesDialog::OnHotkeyTextKeyDown, this);
    m_deleteNodeHotkeyTextCtrl->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent &e) { /* Prevent direct clicks */ });
    deleteHotkeySizer->Add(m_deleteNodeHotkeyTextCtrl, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_deleteNodeHotkeyCaptureButton = new wxButton(panel, ID_DELETE_NODE_HOTKEY_CAPTURE, "Capture");
    m_deleteNodeHotkeyCaptureButton->Bind(wxEVT_BUTTON, &PreferencesDialog::OnHotkeyCaptureClicked, this);
    deleteHotkeySizer->Add(m_deleteNodeHotkeyCaptureButton, 0, wxALIGN_CENTER_VERTICAL);
    navGroup->Add(deleteHotkeySizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(navGroup, 0, wxEXPAND | wxALL, 5);
 
    // Grid group
    wxStaticBoxSizer *gridGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Grid");
 
    m_showGrid = new wxCheckBox(panel, ID_SHOW_GRID, "Show grid");
    m_showGrid->SetForegroundColour(wxColour(200, 200, 200));
    gridGroup->Add(m_showGrid, 0, wxALL, 5);
 
    wxBoxSizer *gridSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *gridSizeLabel = new wxStaticText(panel, wxID_ANY, "Grid size (pixels):");
    gridSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    gridSizeSizer->Add(gridSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_gridSize =
        new wxSpinCtrl(panel, ID_GRID_SIZE, "20", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 10, 100, 20);
    gridSizeSizer->Add(m_gridSize, 0, wxALIGN_CENTER_VERTICAL);
    gridGroup->Add(gridSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Grid background color
    wxBoxSizer *gridBgColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *gridBgColorLabel = new wxStaticText(panel, wxID_ANY, "Grid background color:");
    gridBgColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    gridBgColorSizer->Add(gridBgColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_gridBackgroundPicker = new wxColourPickerCtrl(panel, ID_GRID_BACKGROUND);
    gridBgColorSizer->Add(m_gridBackgroundPicker, 0, wxALIGN_CENTER_VERTICAL);
    gridGroup->Add(gridBgColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Grid line color
    wxBoxSizer *gridLineColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *gridLineColorLabel = new wxStaticText(panel, wxID_ANY, "Grid line color:");
    gridLineColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    gridLineColorSizer->Add(gridLineColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_gridLineColorPicker = new wxColourPickerCtrl(panel, ID_GRID_LINE_COLOR);
    gridLineColorSizer->Add(m_gridLineColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    gridGroup->Add(gridLineColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Connection line color
    wxBoxSizer *connectionColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *connectionColorLabel = new wxStaticText(panel, wxID_ANY, "Connection line color:");
    connectionColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    connectionColorSizer->Add(connectionColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_connectionLineColorPicker = new wxColourPickerCtrl(panel, ID_CONNECTION_LINE_COLOR);
    connectionColorSizer->Add(m_connectionLineColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    gridGroup->Add(connectionColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Highlight path to selected node
    m_highlightPathToSelected = new wxCheckBox(panel, ID_HIGHLIGHT_PATH_TO_SELECTED, "Highlight path to selected node");
    m_highlightPathToSelected->SetForegroundColour(wxColour(200, 200, 200));
    gridGroup->Add(m_highlightPathToSelected, 0, wxALL, 5);
 
    // Path highlight color
    wxBoxSizer *pathHighlightColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *pathHighlightColorLabel = new wxStaticText(panel, wxID_ANY, "Path highlight color:");
    pathHighlightColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    pathHighlightColorSizer->Add(pathHighlightColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_pathHighlightColorPicker = new wxColourPickerCtrl(panel, ID_PATH_HIGHLIGHT_COLOR);
    pathHighlightColorSizer->Add(m_pathHighlightColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    gridGroup->Add(pathHighlightColorSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(gridGroup, 0, wxEXPAND | wxALL, 5);
 
    // Node Appearance group
    wxStaticBoxSizer *nodeAppearanceGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Node Appearance");
 
    // === IDLE NODE SUBSECTION ===
    wxStaticBoxSizer *idleNodeGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Idle Node");
 
    // Background color
    wxBoxSizer *idleNodeBgColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *idleNodeBgColorLabel = new wxStaticText(panel, wxID_ANY, "Background color:");
    idleNodeBgColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    idleNodeBgColorSizer->Add(idleNodeBgColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_idleNodeBgColorPicker = new wxColourPickerCtrl(panel, ID_IDLE_NODE_BG_COLOR);
    idleNodeBgColorSizer->Add(m_idleNodeBgColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    idleNodeGroup->Add(idleNodeBgColorSizer, 0, wxEXPAND | wxALL, 3);
 
    // Border color
    wxBoxSizer *idleNodeBorderColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *idleNodeBorderColorLabel = new wxStaticText(panel, wxID_ANY, "Border color:");
    idleNodeBorderColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    idleNodeBorderColorSizer->Add(idleNodeBorderColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_idleNodeBorderColorPicker = new wxColourPickerCtrl(panel, ID_IDLE_NODE_BORDER_COLOR);
    idleNodeBorderColorSizer->Add(m_idleNodeBorderColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    idleNodeGroup->Add(idleNodeBorderColorSizer, 0, wxEXPAND | wxALL, 3);
 
    // Text color
    wxBoxSizer *idleNodeTextColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *idleNodeTextColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    idleNodeTextColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    idleNodeTextColorSizer->Add(idleNodeTextColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_idleNodeTextColorPicker = new wxColourPickerCtrl(panel, ID_IDLE_NODE_TEXT_COLOR);
    idleNodeTextColorSizer->Add(m_idleNodeTextColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    idleNodeGroup->Add(idleNodeTextColorSizer, 0, wxEXPAND | wxALL, 3);
 
    nodeAppearanceGroup->Add(idleNodeGroup, 0, wxEXPAND | wxALL, 3);
 
    // === HOVERED NODE SUBSECTION ===
    wxStaticBoxSizer *hoveredNodeGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Hovered Node");
 
    // Background tint
    wxBoxSizer *hoveredNodeBgTintSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *hoveredNodeBgTintText = new wxStaticText(panel, wxID_ANY, "Background tint:");
    hoveredNodeBgTintText->SetForegroundColour(wxColour(200, 200, 200));
    hoveredNodeBgTintSizer->Add(hoveredNodeBgTintText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_hoveredNodeBgTint = new wxSlider(panel, ID_HOVERED_NODE_BG_TINT, -13, -100, 100, wxDefaultPosition,
                                       wxSize(200, -1), wxSL_HORIZONTAL);
    m_hoveredNodeBgTint->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    hoveredNodeBgTintSizer->Add(m_hoveredNodeBgTint, 1, wxEXPAND | wxRIGHT, 10);
    m_hoveredNodeBgTintLabel = new wxStaticText(panel, wxID_ANY, "-13%");
    m_hoveredNodeBgTintLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_hoveredNodeBgTintLabel->SetMinSize(wxSize(50, -1));
    hoveredNodeBgTintSizer->Add(m_hoveredNodeBgTintLabel, 0, wxALIGN_CENTER_VERTICAL);
    hoveredNodeGroup->Add(hoveredNodeBgTintSizer, 0, wxEXPAND | wxALL, 3);
 
    // Border color
    wxBoxSizer *hoveredNodeColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *hoveredNodeColorLabel = new wxStaticText(panel, wxID_ANY, "Border color:");
    hoveredNodeColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    hoveredNodeColorSizer->Add(hoveredNodeColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_hoveredNodeColorPicker = new wxColourPickerCtrl(panel, ID_HOVERED_NODE_COLOR);
    hoveredNodeColorSizer->Add(m_hoveredNodeColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    hoveredNodeGroup->Add(hoveredNodeColorSizer, 0, wxEXPAND | wxALL, 3);
 
    // Text color
    wxBoxSizer *hoveredNodeTextColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *hoveredNodeTextColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    hoveredNodeTextColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    hoveredNodeTextColorSizer->Add(hoveredNodeTextColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_hoveredNodeTextColorPicker = new wxColourPickerCtrl(panel, ID_HOVERED_NODE_TEXT_COLOR);
    hoveredNodeTextColorSizer->Add(m_hoveredNodeTextColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    hoveredNodeGroup->Add(hoveredNodeTextColorSizer, 0, wxEXPAND | wxALL, 3);
 
    // Info text color
    wxBoxSizer *hoveredNodeInfoColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *hoveredNodeInfoColorLabel = new wxStaticText(panel, wxID_ANY, "Info text color:");
    hoveredNodeInfoColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    hoveredNodeInfoColorSizer->Add(hoveredNodeInfoColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_hoveredNodeInfoColorPicker = new wxColourPickerCtrl(panel, ID_HOVERED_NODE_INFO_COLOR);
    hoveredNodeInfoColorSizer->Add(m_hoveredNodeInfoColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    hoveredNodeGroup->Add(hoveredNodeInfoColorSizer, 0, wxEXPAND | wxALL, 3);
 
    nodeAppearanceGroup->Add(hoveredNodeGroup, 0, wxEXPAND | wxALL, 3);
 
    // === SELECTED NODE SUBSECTION ===
    wxStaticBoxSizer *selectedNodeGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Selected Node");
 
    // Background tint
    wxBoxSizer *selectedNodeBgTintSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selectedNodeBgTintText = new wxStaticText(panel, wxID_ANY, "Background tint:");
    selectedNodeBgTintText->SetForegroundColour(wxColour(200, 200, 200));
    selectedNodeBgTintSizer->Add(selectedNodeBgTintText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_selectedNodeBgTint = new wxSlider(panel, ID_SELECTED_NODE_BG_TINT, -33, -100, 100, wxDefaultPosition,
                                        wxSize(200, -1), wxSL_HORIZONTAL);
    m_selectedNodeBgTint->Bind(wxEVT_MOUSEWHEEL, &PreferencesDialog::OnSliderMouseWheel, this);
    selectedNodeBgTintSizer->Add(m_selectedNodeBgTint, 1, wxEXPAND | wxRIGHT, 10);
    m_selectedNodeBgTintLabel = new wxStaticText(panel, wxID_ANY, "-33%");
    m_selectedNodeBgTintLabel->SetForegroundColour(wxColour(200, 200, 200));
    m_selectedNodeBgTintLabel->SetMinSize(wxSize(50, -1));
    selectedNodeBgTintSizer->Add(m_selectedNodeBgTintLabel, 0, wxALIGN_CENTER_VERTICAL);
    selectedNodeGroup->Add(selectedNodeBgTintSizer, 0, wxEXPAND | wxALL, 3);
 
    // Border color
    wxBoxSizer *selectedNodeColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selectedNodeColorLabel = new wxStaticText(panel, wxID_ANY, "Border color:");
    selectedNodeColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    selectedNodeColorSizer->Add(selectedNodeColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_selectedNodeColorPicker = new wxColourPickerCtrl(panel, ID_SELECTED_NODE_COLOR);
    selectedNodeColorSizer->Add(m_selectedNodeColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    selectedNodeGroup->Add(selectedNodeColorSizer, 0, wxEXPAND | wxALL, 3);
 
    // Text color
    wxBoxSizer *selectedNodeTextColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selectedNodeTextColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    selectedNodeTextColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    selectedNodeTextColorSizer->Add(selectedNodeTextColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_selectedNodeTextColorPicker = new wxColourPickerCtrl(panel, ID_SELECTED_NODE_TEXT_COLOR);
    selectedNodeTextColorSizer->Add(m_selectedNodeTextColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    selectedNodeGroup->Add(selectedNodeTextColorSizer, 0, wxEXPAND | wxALL, 3);
 
    // Info text color
    wxBoxSizer *selectedNodeInfoColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selectedNodeInfoColorLabel = new wxStaticText(panel, wxID_ANY, "Info text color:");
    selectedNodeInfoColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    selectedNodeInfoColorSizer->Add(selectedNodeInfoColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_selectedNodeInfoColorPicker = new wxColourPickerCtrl(panel, ID_SELECTED_NODE_INFO_COLOR);
    selectedNodeInfoColorSizer->Add(m_selectedNodeInfoColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    selectedNodeGroup->Add(selectedNodeInfoColorSizer, 0, wxEXPAND | wxALL, 3);
 
    nodeAppearanceGroup->Add(selectedNodeGroup, 0, wxEXPAND | wxALL, 3);
 
    panelSizer->Add(nodeAppearanceGroup, 0, wxEXPAND | wxALL, 5);
 
    // ==================== DEBUG TEXT CUSTOMIZATION SECTIONS ====================
 
    // === COORDINATE SYSTEM INFO (Zoom & Pan) ===
    wxStaticBoxSizer *coordInfoGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Coordinate System Info (Zoom & Pan)");
 
    m_showCoordinateInfo = new wxCheckBox(panel, ID_SHOW_COORDINATE_INFO, "Show coordinate system info");
    if (m_showCoordinateInfo) {
        m_showCoordinateInfo->SetForegroundColour(wxColour(200, 200, 200));
        coordInfoGroup->Add(m_showCoordinateInfo, 0, wxALL, 5);
    }
 
    // Font size
    wxBoxSizer *coordFontSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *coordFontSizeLabel = new wxStaticText(panel, wxID_ANY, "Font size:");
    if (coordFontSizeLabel) {
        coordFontSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
        coordFontSizeSizer->Add(coordFontSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    }
    m_coordinateInfoFontSize = new wxSpinCtrl(panel, ID_COORDINATE_INFO_FONT_SIZE, "9", wxDefaultPosition,
                                              wxSize(120, -1), wxSP_ARROW_KEYS, 6, 20, 9);
    if (m_coordinateInfoFontSize) {
        coordFontSizeSizer->Add(m_coordinateInfoFontSize, 0, wxALIGN_CENTER_VERTICAL);
    }
    if (coordFontSizeSizer->GetItemCount() > 0) {
        coordInfoGroup->Add(coordFontSizeSizer, 0, wxEXPAND | wxALL, 5);
    }
 
    // Color
    wxBoxSizer *coordColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *coordColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    coordColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    coordColorSizer->Add(coordColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_coordinateInfoColorPicker = new wxColourPickerCtrl(panel, ID_COORDINATE_INFO_COLOR);
    coordColorSizer->Add(m_coordinateInfoColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    coordInfoGroup->Add(coordColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Anchor
    wxBoxSizer *coordAnchorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *coordAnchorLabel = new wxStaticText(panel, wxID_ANY, "Anchor:");
    coordAnchorLabel->SetForegroundColour(wxColour(200, 200, 200));
    coordAnchorSizer->Add(coordAnchorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxArrayString anchorChoices;
    anchorChoices.Add("Top-Left");
    anchorChoices.Add("Top-Right");
    anchorChoices.Add("Bottom-Left");
    anchorChoices.Add("Bottom-Right");
    m_coordinateInfoAnchor = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxSize(150, -1), anchorChoices);
    m_coordinateInfoAnchor->SetSelection(0);
    coordAnchorSizer->Add(m_coordinateInfoAnchor, 0, wxALIGN_CENTER_VERTICAL);
    coordInfoGroup->Add(coordAnchorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Position X and Y
    wxBoxSizer *coordPosSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *coordPosLabel = new wxStaticText(panel, wxID_ANY, "Offset:");
    coordPosLabel->SetForegroundColour(wxColour(200, 200, 200));
    coordPosSizer->Add(coordPosLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *coordXLabel = new wxStaticText(panel, wxID_ANY, "X:");
    coordXLabel->SetForegroundColour(wxColour(200, 200, 200));
    coordPosSizer->Add(coordXLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_coordinateInfoX = new wxSpinCtrl(panel, ID_COORDINATE_INFO_X, "10", wxDefaultPosition, wxSize(120, -1),
                                       wxSP_ARROW_KEYS, 0, 9999, 10);
    coordPosSizer->Add(m_coordinateInfoX, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *coordYLabel = new wxStaticText(panel, wxID_ANY, "Y:");
    coordYLabel->SetForegroundColour(wxColour(200, 200, 200));
    coordPosSizer->Add(coordYLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_coordinateInfoY = new wxSpinCtrl(panel, ID_COORDINATE_INFO_Y, "10", wxDefaultPosition, wxSize(120, -1),
                                       wxSP_ARROW_KEYS, 0, 9999, 10);
    coordPosSizer->Add(m_coordinateInfoY, 0, wxALIGN_CENTER_VERTICAL);
    coordInfoGroup->Add(coordPosSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(coordInfoGroup, 0, wxEXPAND | wxALL, 5);
 
    // === SELECTED NODE INFO ===
    wxStaticBoxSizer *selectedInfoGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Selected Node Info");
 
    m_showSelectedNodeInfo = new wxCheckBox(panel, ID_SHOW_SELECTED_NODE_INFO, "Show selected node info");
    m_showSelectedNodeInfo->SetForegroundColour(wxColour(200, 200, 200));
    selectedInfoGroup->Add(m_showSelectedNodeInfo, 0, wxALL, 5);
 
    // Font size
    wxBoxSizer *selFontSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selFontSizeLabel = new wxStaticText(panel, wxID_ANY, "Font size:");
    selFontSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    selFontSizeSizer->Add(selFontSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_selectedNodeInfoFontSize = new wxSpinCtrl(panel, ID_SELECTED_NODE_INFO_FONT_SIZE, "9", wxDefaultPosition,
                                                wxSize(120, -1), wxSP_ARROW_KEYS, 6, 20, 9);
    selFontSizeSizer->Add(m_selectedNodeInfoFontSize, 0, wxALIGN_CENTER_VERTICAL);
    selectedInfoGroup->Add(selFontSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Color
    wxBoxSizer *selColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    selColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    selColorSizer->Add(selColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_selectedNodeDebugInfoColorPicker = new wxColourPickerCtrl(panel, ID_SELECTED_NODE_DEBUG_INFO_COLOR);
    selColorSizer->Add(m_selectedNodeDebugInfoColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    selectedInfoGroup->Add(selColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Anchor
    wxBoxSizer *selAnchorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selAnchorLabel = new wxStaticText(panel, wxID_ANY, "Anchor:");
    selAnchorLabel->SetForegroundColour(wxColour(200, 200, 200));
    selAnchorSizer->Add(selAnchorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_selectedNodeInfoAnchor = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxSize(150, -1), anchorChoices);
    m_selectedNodeInfoAnchor->SetSelection(0);
    selAnchorSizer->Add(m_selectedNodeInfoAnchor, 0, wxALIGN_CENTER_VERTICAL);
    selectedInfoGroup->Add(selAnchorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Position X and Y
    wxBoxSizer *selPosSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *selPosLabel = new wxStaticText(panel, wxID_ANY, "Offset:");
    selPosLabel->SetForegroundColour(wxColour(200, 200, 200));
    selPosSizer->Add(selPosLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *selXLabel = new wxStaticText(panel, wxID_ANY, "X:");
    selXLabel->SetForegroundColour(wxColour(200, 200, 200));
    selPosSizer->Add(selXLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_selectedNodeInfoX = new wxSpinCtrl(panel, ID_SELECTED_NODE_INFO_X, "10", wxDefaultPosition, wxSize(120, -1),
                                         wxSP_ARROW_KEYS, 0, 9999, 10);
    selPosSizer->Add(m_selectedNodeInfoX, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *selYLabel = new wxStaticText(panel, wxID_ANY, "Y:");
    selYLabel->SetForegroundColour(wxColour(200, 200, 200));
    selPosSizer->Add(selYLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_selectedNodeInfoY = new wxSpinCtrl(panel, ID_SELECTED_NODE_INFO_Y, "30", wxDefaultPosition, wxSize(120, -1),
                                         wxSP_ARROW_KEYS, 0, 9999, 30);
    selPosSizer->Add(m_selectedNodeInfoY, 0, wxALIGN_CENTER_VERTICAL);
    selectedInfoGroup->Add(selPosSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(selectedInfoGroup, 0, wxEXPAND | wxALL, 5);
 
    // === TREE STATISTICS INFO ===
    wxStaticBoxSizer *treeStatsGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Tree Statistics Info");
 
    m_showTreeInfo = new wxCheckBox(panel, ID_SHOW_TREE_INFO, "Show tree statistics");
    m_showTreeInfo->SetForegroundColour(wxColour(200, 200, 200));
    treeStatsGroup->Add(m_showTreeInfo, 0, wxALL, 5);
 
    // Font size
    wxBoxSizer *treeFontSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *treeFontSizeLabel = new wxStaticText(panel, wxID_ANY, "Font size:");
    treeFontSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    treeFontSizeSizer->Add(treeFontSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_treeInfoFontSize = new wxSpinCtrl(panel, ID_TREE_INFO_FONT_SIZE, "9", wxDefaultPosition, wxSize(120, -1),
                                        wxSP_ARROW_KEYS, 6, 20, 9);
    treeFontSizeSizer->Add(m_treeInfoFontSize, 0, wxALIGN_CENTER_VERTICAL);
    treeStatsGroup->Add(treeFontSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Color
    wxBoxSizer *treeColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *treeColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    treeColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    treeColorSizer->Add(treeColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_treeInfoColorPicker = new wxColourPickerCtrl(panel, ID_TREE_INFO_COLOR);
    treeColorSizer->Add(m_treeInfoColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    treeStatsGroup->Add(treeColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Anchor
    wxBoxSizer *treeAnchorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *treeAnchorLabel = new wxStaticText(panel, wxID_ANY, "Anchor:");
    treeAnchorLabel->SetForegroundColour(wxColour(200, 200, 200));
    treeAnchorSizer->Add(treeAnchorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_treeInfoAnchor = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxSize(150, -1), anchorChoices);
    m_treeInfoAnchor->SetSelection(0);
    treeAnchorSizer->Add(m_treeInfoAnchor, 0, wxALIGN_CENTER_VERTICAL);
    treeStatsGroup->Add(treeAnchorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Position X and Y
    wxBoxSizer *treePosSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *treePosLabel = new wxStaticText(panel, wxID_ANY, "Offset:");
    treePosLabel->SetForegroundColour(wxColour(200, 200, 200));
    treePosSizer->Add(treePosLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *treeXLabel = new wxStaticText(panel, wxID_ANY, "X:");
    treeXLabel->SetForegroundColour(wxColour(200, 200, 200));
    treePosSizer->Add(treeXLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_treeInfoX =
        new wxSpinCtrl(panel, ID_TREE_INFO_X, "10", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 0, 9999, 10);
    treePosSizer->Add(m_treeInfoX, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *treeYLabel = new wxStaticText(panel, wxID_ANY, "Y:");
    treeYLabel->SetForegroundColour(wxColour(200, 200, 200));
    treePosSizer->Add(treeYLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_treeInfoY =
        new wxSpinCtrl(panel, ID_TREE_INFO_Y, "50", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 0, 9999, 50);
    treePosSizer->Add(m_treeInfoY, 0, wxALIGN_CENTER_VERTICAL);
    treeStatsGroup->Add(treePosSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(treeStatsGroup, 0, wxEXPAND | wxALL, 5);
 
    // === FPS DISPLAY ===
    wxStaticBoxSizer *fpsGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "FPS Display");
 
    m_showFPS = new wxCheckBox(panel, wxID_ANY, "Show FPS counter");
    m_showFPS->SetForegroundColour(wxColour(200, 200, 200));
    fpsGroup->Add(m_showFPS, 0, wxALL, 5);
 
    // Font size
    wxBoxSizer *fpsFontSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *fpsFontSizeLabel = new wxStaticText(panel, wxID_ANY, "Font size:");
    fpsFontSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    fpsFontSizeSizer->Add(fpsFontSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_fpsFontSize = new wxSpinCtrl(panel, wxID_ANY, "9", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 6, 20, 9);
    fpsFontSizeSizer->Add(m_fpsFontSize, 0, wxALIGN_CENTER_VERTICAL);
    fpsGroup->Add(fpsFontSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Color
    wxBoxSizer *fpsColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *fpsColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    fpsColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    fpsColorSizer->Add(fpsColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_fpsColorPicker = new wxColourPickerCtrl(panel, wxID_ANY);
    fpsColorSizer->Add(m_fpsColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    fpsGroup->Add(fpsColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Anchor
    wxBoxSizer *fpsAnchorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *fpsAnchorLabel = new wxStaticText(panel, wxID_ANY, "Anchor:");
    fpsAnchorLabel->SetForegroundColour(wxColour(200, 200, 200));
    fpsAnchorSizer->Add(fpsAnchorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_fpsAnchor = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxSize(150, -1), anchorChoices);
    m_fpsAnchor->SetSelection(0); // Default to Top-Left
    fpsAnchorSizer->Add(m_fpsAnchor, 0, wxALIGN_CENTER_VERTICAL);
    fpsGroup->Add(fpsAnchorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Position X and Y
    wxBoxSizer *fpsPosSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *fpsPosLabel = new wxStaticText(panel, wxID_ANY, "Offset:");
    fpsPosLabel->SetForegroundColour(wxColour(200, 200, 200));
    fpsPosSizer->Add(fpsPosLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *fpsXLabel = new wxStaticText(panel, wxID_ANY, "X:");
    fpsXLabel->SetForegroundColour(wxColour(200, 200, 200));
    fpsPosSizer->Add(fpsXLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_fpsX = new wxSpinCtrl(panel, wxID_ANY, "10", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 0, 9999, 10);
    fpsPosSizer->Add(m_fpsX, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *fpsYLabel = new wxStaticText(panel, wxID_ANY, "Y:");
    fpsYLabel->SetForegroundColour(wxColour(200, 200, 200));
    fpsPosSizer->Add(fpsYLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_fpsY = new wxSpinCtrl(panel, wxID_ANY, "70", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 0, 9999, 70);
    fpsPosSizer->Add(m_fpsY, 0, wxALIGN_CENTER_VERTICAL);
    fpsGroup->Add(fpsPosSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(fpsGroup, 0, wxEXPAND | wxALL, 5);
 
    // === CONTROLS HELP TEXT ===
    wxStaticBoxSizer *controlsHelpGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Controls Help Text");
 
    m_showControlsHelp = new wxCheckBox(panel, ID_SHOW_CONTROLS_HELP, "Show controls/hotkeys help");
    m_showControlsHelp->SetForegroundColour(wxColour(200, 200, 200));
    controlsHelpGroup->Add(m_showControlsHelp, 0, wxALL, 5);
 
    // Font size
    wxBoxSizer *ctrlFontSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *ctrlFontSizeLabel = new wxStaticText(panel, wxID_ANY, "Font size:");
    ctrlFontSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    ctrlFontSizeSizer->Add(ctrlFontSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_controlsHelpFontSize = new wxSpinCtrl(panel, ID_CONTROLS_HELP_FONT_SIZE, "11", wxDefaultPosition, wxSize(120, -1),
                                            wxSP_ARROW_KEYS, 6, 20, 11);
    ctrlFontSizeSizer->Add(m_controlsHelpFontSize, 0, wxALIGN_CENTER_VERTICAL);
    controlsHelpGroup->Add(ctrlFontSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    // Color
    wxBoxSizer *ctrlColorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *ctrlColorLabel = new wxStaticText(panel, wxID_ANY, "Text color:");
    ctrlColorLabel->SetForegroundColour(wxColour(200, 200, 200));
    ctrlColorSizer->Add(ctrlColorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_controlsHelpColorPicker = new wxColourPickerCtrl(panel, ID_CONTROLS_HELP_COLOR);
    ctrlColorSizer->Add(m_controlsHelpColorPicker, 0, wxALIGN_CENTER_VERTICAL);
    controlsHelpGroup->Add(ctrlColorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Anchor
    wxBoxSizer *ctrlAnchorSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *ctrlAnchorLabel = new wxStaticText(panel, wxID_ANY, "Anchor:");
    ctrlAnchorLabel->SetForegroundColour(wxColour(200, 200, 200));
    ctrlAnchorSizer->Add(ctrlAnchorLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    m_controlsHelpAnchor = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxSize(150, -1), anchorChoices);
    m_controlsHelpAnchor->SetSelection(2); // Default to Bottom-Left
    ctrlAnchorSizer->Add(m_controlsHelpAnchor, 0, wxALIGN_CENTER_VERTICAL);
    controlsHelpGroup->Add(ctrlAnchorSizer, 0, wxEXPAND | wxALL, 5);
 
    // Position X and Y
    wxBoxSizer *ctrlPosSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *ctrlPosLabel = new wxStaticText(panel, wxID_ANY, "Offset:");
    ctrlPosLabel->SetForegroundColour(wxColour(200, 200, 200));
    ctrlPosSizer->Add(ctrlPosLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *ctrlXLabel = new wxStaticText(panel, wxID_ANY, "X:");
    ctrlXLabel->SetForegroundColour(wxColour(200, 200, 200));
    ctrlPosSizer->Add(ctrlXLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_controlsHelpX = new wxSpinCtrl(panel, ID_CONTROLS_HELP_X, "10", wxDefaultPosition, wxSize(120, -1),
                                     wxSP_ARROW_KEYS, 0, 9999, 10);
    ctrlPosSizer->Add(m_controlsHelpX, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
    wxStaticText *ctrlYLabel = new wxStaticText(panel, wxID_ANY, "Y:");
    ctrlYLabel->SetForegroundColour(wxColour(200, 200, 200));
    ctrlPosSizer->Add(ctrlYLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
    m_controlsHelpY = new wxSpinCtrl(panel, ID_CONTROLS_HELP_Y, "25", wxDefaultPosition, wxSize(120, -1),
                                     wxSP_ARROW_KEYS, 0, 9999, 25);
    ctrlPosSizer->Add(m_controlsHelpY, 0, wxALIGN_CENTER_VERTICAL);
    controlsHelpGroup->Add(ctrlPosSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(controlsHelpGroup, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateBottomPanelSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // Panel Layout group
    wxStaticBoxSizer *layoutGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Panel Layout");
 
    // Default panel height
    wxBoxSizer *heightSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_bottomPanelHeightEnabled =
        new wxCheckBox(panel, ID_BOTTOM_PANEL_HEIGHT_ENABLED, "Default panel height (% of window):");
    m_bottomPanelHeightEnabled->SetForegroundColour(wxColour(200, 200, 200));
    m_bottomPanelHeightEnabled->SetValue(true);
    m_bottomPanelHeightEnabled->Bind(wxEVT_CHECKBOX, &PreferencesDialog::OnBottomPanelHeightEnabledChanged, this);
    heightSizer->Add(m_bottomPanelHeightEnabled, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_bottomPanelHeight =
        new wxSpinCtrl(panel, wxID_ANY, "25", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 5, 80, 25);
    heightSizer->Add(m_bottomPanelHeight, 0, wxALIGN_CENTER_VERTICAL);
    layoutGroup->Add(heightSizer, 0, wxEXPAND | wxALL, 5);
 
    // Minimum panel height
    wxBoxSizer *minHeightSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_bottomPanelMinHeightEnabled =
        new wxCheckBox(panel, ID_BOTTOM_PANEL_MIN_HEIGHT_ENABLED, "Minimum panel height (% of window):");
    m_bottomPanelMinHeightEnabled->SetForegroundColour(wxColour(200, 200, 200));
    m_bottomPanelMinHeightEnabled->SetValue(true);
    m_bottomPanelMinHeightEnabled->Bind(wxEVT_CHECKBOX, &PreferencesDialog::OnBottomPanelMinHeightEnabledChanged, this);
    minHeightSizer->Add(m_bottomPanelMinHeightEnabled, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_bottomPanelMinHeight =
        new wxSpinCtrl(panel, wxID_ANY, "15", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 5, 50, 15);
    minHeightSizer->Add(m_bottomPanelMinHeight, 0, wxALIGN_CENTER_VERTICAL);
    layoutGroup->Add(minHeightSizer, 0, wxEXPAND | wxALL, 5);
 
    // Show panel on startup
    wxBoxSizer *startupSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *startupLabel = new wxStaticText(panel, wxID_ANY, "On startup:");
    startupLabel->SetForegroundColour(wxColour(200, 200, 200));
    startupSizer->Add(startupLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString startupOptions;
    startupOptions.Add("Show panel");
    startupOptions.Add("Hide panel");
    startupOptions.Add("Remember last state");
    m_bottomPanelStartup = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, startupOptions);
    m_bottomPanelStartup->SetSelection(0);
    startupSizer->Add(m_bottomPanelStartup, 1, wxEXPAND);
    layoutGroup->Add(startupSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(layoutGroup, 0, wxEXPAND | wxALL, 5);
 
    // Tab Bar group
    wxStaticBoxSizer *tabBarGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Tab Bar");
 
    m_showTabCloseButtons = new wxCheckBox(panel, wxID_ANY, "Show close buttons on tabs");
    m_showTabCloseButtons->SetForegroundColour(wxColour(200, 200, 200));
    m_showTabCloseButtons->SetValue(true);
    tabBarGroup->Add(m_showTabCloseButtons, 0, wxALL, 5);
 
    panelSizer->Add(tabBarGroup, 0, wxEXPAND | wxALL, 5);
 
    // Behavior group
    wxStaticBoxSizer *behaviorGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Behavior");
 
    m_rememberLastTab = new wxCheckBox(panel, wxID_ANY, "Remember last active tab between sessions");
    m_rememberLastTab->SetForegroundColour(wxColour(200, 200, 200));
    m_rememberLastTab->SetValue(true);
    behaviorGroup->Add(m_rememberLastTab, 0, wxALL, 5);
 
    m_allowPanelCollapse = new wxCheckBox(panel, wxID_ANY, "Allow panel collapse (drag splitter to hide)");
    m_allowPanelCollapse->SetForegroundColour(wxColour(200, 200, 200));
    m_allowPanelCollapse->SetValue(true);
    behaviorGroup->Add(m_allowPanelCollapse, 0, wxALL, 5);
 
    panelSizer->Add(behaviorGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateFileExplorerTabSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // General Settings group
    wxStaticBoxSizer *generalGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "General");
 
    m_showBreadcrumb = new wxCheckBox(panel, wxID_ANY, "Show breadcrumb navigation");
    m_showBreadcrumb->SetForegroundColour(wxColour(200, 200, 200));
    generalGroup->Add(m_showBreadcrumb, 0, wxALL, 5);
 
    m_showHistory = new wxCheckBox(panel, wxID_ANY, "Show navigation history button");
    m_showHistory->SetForegroundColour(wxColour(200, 200, 200));
    generalGroup->Add(m_showHistory, 0, wxALL, 5);
 
    // Start Path Mode
    wxBoxSizer *startPathSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *startPathLabel = new wxStaticText(panel, wxID_ANY, "Default start path:");
    startPathLabel->SetForegroundColour(wxColour(200, 200, 200));
    startPathSizer->Add(startPathLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString startPathOptions;
    startPathOptions.Add("Executable Directory");
    startPathOptions.Add("Custom Path");
    m_startPathMode = new wxChoice(panel, ID_START_PATH_MODE, wxDefaultPosition, wxDefaultSize, startPathOptions);
    startPathSizer->Add(m_startPathMode, 1, wxEXPAND);
    generalGroup->Add(startPathSizer, 0, wxEXPAND | wxALL, 5);
 
    // Custom Path
    wxBoxSizer *customPathSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *customPathLabel = new wxStaticText(panel, wxID_ANY, "Custom path:");
    customPathLabel->SetForegroundColour(wxColour(200, 200, 200));
    customPathSizer->Add(customPathLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_customStartPath = new wxTextCtrl(panel, ID_CUSTOM_START_PATH);
    m_customStartPath->SetBackgroundColour(wxColour(60, 60, 60));
    m_customStartPath->SetForegroundColour(wxColour(200, 200, 200));
    customPathSizer->Add(m_customStartPath, 1, wxEXPAND | wxRIGHT, 5);
 
    m_browseStartPath = new wxButton(panel, ID_BROWSE_START_PATH, "Browse...", wxDefaultPosition, wxSize(80, -1));
    customPathSizer->Add(m_browseStartPath, 0);
    generalGroup->Add(customPathSizer, 0, wxEXPAND | wxALL, 5);
 
    // Bind events
    m_startPathMode->Bind(wxEVT_CHOICE, &PreferencesDialog::OnStartPathModeChanged, this);
    m_browseStartPath->Bind(wxEVT_BUTTON, &PreferencesDialog::OnBrowseStartPath, this);
 
    panelSizer->Add(generalGroup, 0, wxEXPAND | wxALL, 5);
 
    // Tree View Settings group
    wxStaticBoxSizer *treeViewGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Tree View");
 
    m_treeShowHiddenFiles = new wxCheckBox(panel, ID_TREE_SHOW_HIDDEN_FILES, "Show hidden files");
    m_treeShowHiddenFiles->SetForegroundColour(wxColour(200, 200, 200));
    treeViewGroup->Add(m_treeShowHiddenFiles, 0, wxALL, 5);
 
    m_treeShowFileExtensions = new wxCheckBox(panel, ID_TREE_SHOW_EXTENSIONS, "Show file extensions");
    m_treeShowFileExtensions->SetForegroundColour(wxColour(200, 200, 200));
    treeViewGroup->Add(m_treeShowFileExtensions, 0, wxALL, 5);
 
    // Tree Sort by
    wxBoxSizer *treeSortBySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *treeSortByLabel = new wxStaticText(panel, wxID_ANY, "Sort files by:");
    treeSortByLabel->SetForegroundColour(wxColour(200, 200, 200));
    treeSortBySizer->Add(treeSortByLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString sortOptions;
    sortOptions.Add("Name");
    sortOptions.Add("Date");
    sortOptions.Add("Size");
    sortOptions.Add("Type");
    m_treeSortFilesBy = new wxChoice(panel, ID_TREE_SORT_FILES_BY, wxDefaultPosition, wxDefaultSize, sortOptions);
    treeSortBySizer->Add(m_treeSortFilesBy, 1, wxEXPAND);
    treeViewGroup->Add(treeSortBySizer, 0, wxEXPAND | wxALL, 5);
 
    // Tree Item Size
    wxBoxSizer *treeItemSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *treeItemSizeLabel = new wxStaticText(panel, wxID_ANY, "Item size:");
    treeItemSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    treeItemSizeSizer->Add(treeItemSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString treeItemSizeOptions;
    treeItemSizeOptions.Add("Small (Compact)");
    treeItemSizeOptions.Add("Medium (Standard)");
    treeItemSizeOptions.Add("Large (Spacious)");
    m_treeItemSize = new wxChoice(panel, ID_TREE_ITEM_SIZE, wxDefaultPosition, wxDefaultSize, treeItemSizeOptions);
    treeItemSizeSizer->Add(m_treeItemSize, 1, wxEXPAND);
    treeViewGroup->Add(treeItemSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(treeViewGroup, 0, wxEXPAND | wxALL, 5);
 
    // Grid View Settings group
    wxStaticBoxSizer *gridViewGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Grid View");
 
    m_gridShowHiddenFiles = new wxCheckBox(panel, ID_GRID_SHOW_HIDDEN_FILES, "Show hidden files");
    m_gridShowHiddenFiles->SetForegroundColour(wxColour(200, 200, 200));
    gridViewGroup->Add(m_gridShowHiddenFiles, 0, wxALL, 5);
 
    m_gridShowFileExtensions = new wxCheckBox(panel, ID_GRID_SHOW_EXTENSIONS, "Show file extensions");
    m_gridShowFileExtensions->SetForegroundColour(wxColour(200, 200, 200));
    gridViewGroup->Add(m_gridShowFileExtensions, 0, wxALL, 5);
 
    // Grid Sort by
    wxBoxSizer *gridSortBySizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *gridSortByLabel = new wxStaticText(panel, wxID_ANY, "Sort files by:");
    gridSortByLabel->SetForegroundColour(wxColour(200, 200, 200));
    gridSortBySizer->Add(gridSortByLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_gridSortFilesBy = new wxChoice(panel, ID_GRID_SORT_FILES_BY, wxDefaultPosition, wxDefaultSize, sortOptions);
    gridSortBySizer->Add(m_gridSortFilesBy, 1, wxEXPAND);
    gridViewGroup->Add(gridSortBySizer, 0, wxEXPAND | wxALL, 5);
 
    // Icon Size
    wxBoxSizer *iconSizeSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *iconSizeLabel = new wxStaticText(panel, wxID_ANY, "Icon size:");
    iconSizeLabel->SetForegroundColour(wxColour(200, 200, 200));
    iconSizeSizer->Add(iconSizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString iconSizeOptions;
    iconSizeOptions.Add("Small (48x48)");
    iconSizeOptions.Add("Medium (80x80)");
    iconSizeOptions.Add("Large (128x128)");
    m_gridIconSize = new wxChoice(panel, ID_GRID_ICON_SIZE, wxDefaultPosition, wxDefaultSize, iconSizeOptions);
    iconSizeSizer->Add(m_gridIconSize, 1, wxEXPAND);
    gridViewGroup->Add(iconSizeSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(gridViewGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateSidePanelSettings(wxWindow *parent) {
    // Global side panel settings (currently empty - reserved for future global settings)
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    wxStaticText *infoText = new wxStaticText(panel, wxID_ANY,
                                              "Global settings for all side panels.\n\n"
                                              "Configure individual panels:\n"
                                              "  • Left Panel - Settings for the left side panel\n"
                                              "  • Right Panel - Settings for the right side panel\n"
                                              "  • Bottom Panel - Settings for the bottom panel");
    infoText->SetForegroundColour(wxColour(180, 180, 180));
    panelSizer->Add(infoText, 0, wxALL, 10);
 
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateTabsSubSettings(wxWindow *parent) {
    // Placeholder panel for "Tabs" submenu (navigation node)
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    wxStaticText *infoText = new wxStaticText(panel, wxID_ANY,
                                              "Tab-specific settings.\n\n"
                                              "Configure individual tabs:\n"
                                              "  • File Explorer Tab - Settings for file browsing\n"
                                              "  • Log Tab - Settings for log display\n"
                                              "  • Scene Hierarchy Tab - Settings for scene hierarchy display");
    infoText->SetForegroundColour(wxColour(180, 180, 180));
    panelSizer->Add(infoText, 0, wxALL, 10);
 
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateLeftPanelSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // Panel Layout group
    wxStaticBoxSizer *layoutGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Panel Layout");
 
    // Default panel width
    wxBoxSizer *widthSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_leftPanelWidthEnabled = new wxCheckBox(panel, ID_LEFT_PANEL_WIDTH_ENABLED, "Default panel width (% of window):");
    m_leftPanelWidthEnabled->SetForegroundColour(wxColour(200, 200, 200));
    m_leftPanelWidthEnabled->SetValue(true);
    m_leftPanelWidthEnabled->Bind(wxEVT_CHECKBOX, &PreferencesDialog::OnLeftPanelWidthEnabledChanged, this);
    widthSizer->Add(m_leftPanelWidthEnabled, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_leftPanelWidth =
        new wxSpinCtrl(panel, wxID_ANY, "20", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 5, 80, 20);
    widthSizer->Add(m_leftPanelWidth, 0, wxALIGN_CENTER_VERTICAL);
    layoutGroup->Add(widthSizer, 0, wxEXPAND | wxALL, 5);
 
    // Minimum panel width
    wxBoxSizer *minWidthSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_leftPanelMinWidthEnabled =
        new wxCheckBox(panel, ID_LEFT_PANEL_MIN_WIDTH_ENABLED, "Minimum panel width (% of window):");
    m_leftPanelMinWidthEnabled->SetForegroundColour(wxColour(200, 200, 200));
    m_leftPanelMinWidthEnabled->SetValue(true);
    m_leftPanelMinWidthEnabled->Bind(wxEVT_CHECKBOX, &PreferencesDialog::OnLeftPanelMinWidthEnabledChanged, this);
    minWidthSizer->Add(m_leftPanelMinWidthEnabled, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_leftPanelMinWidth =
        new wxSpinCtrl(panel, wxID_ANY, "10", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 5, 50, 10);
    minWidthSizer->Add(m_leftPanelMinWidth, 0, wxALIGN_CENTER_VERTICAL);
    layoutGroup->Add(minWidthSizer, 0, wxEXPAND | wxALL, 5);
 
    // Show panel on startup
    wxBoxSizer *startupSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *startupLabel = new wxStaticText(panel, wxID_ANY, "On startup:");
    startupLabel->SetForegroundColour(wxColour(200, 200, 200));
    startupSizer->Add(startupLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString startupOptions;
    startupOptions.Add("Show panel");
    startupOptions.Add("Hide panel");
    startupOptions.Add("Remember last state");
    m_leftPanelStartup = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, startupOptions);
    m_leftPanelStartup->SetSelection(0);
    startupSizer->Add(m_leftPanelStartup, 1, wxEXPAND);
    layoutGroup->Add(startupSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(layoutGroup, 0, wxEXPAND | wxALL, 5);
 
    // Tab Bar group
    wxStaticBoxSizer *tabBarGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Tab Bar");
 
    m_leftPanelShowTabCloseButtons = new wxCheckBox(panel, wxID_ANY, "Show close buttons on tabs");
    m_leftPanelShowTabCloseButtons->SetForegroundColour(wxColour(200, 200, 200));
    m_leftPanelShowTabCloseButtons->SetValue(true);
    tabBarGroup->Add(m_leftPanelShowTabCloseButtons, 0, wxALL, 5);
 
    panelSizer->Add(tabBarGroup, 0, wxEXPAND | wxALL, 5);
 
    // Behavior group
    wxStaticBoxSizer *behaviorGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Behavior");
 
    m_leftPanelRememberLastTab = new wxCheckBox(panel, wxID_ANY, "Remember last active tab between sessions");
    m_leftPanelRememberLastTab->SetForegroundColour(wxColour(200, 200, 200));
    m_leftPanelRememberLastTab->SetValue(true);
    behaviorGroup->Add(m_leftPanelRememberLastTab, 0, wxALL, 5);
 
    m_leftPanelAllowCollapse = new wxCheckBox(panel, wxID_ANY, "Allow panel collapse (drag splitter to hide)");
    m_leftPanelAllowCollapse->SetForegroundColour(wxColour(200, 200, 200));
    m_leftPanelAllowCollapse->SetValue(true);
    behaviorGroup->Add(m_leftPanelAllowCollapse, 0, wxALL, 5);
 
    panelSizer->Add(behaviorGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateRightPanelSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // Panel Layout group
    wxStaticBoxSizer *layoutGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Panel Layout");
 
    // Default panel width
    wxBoxSizer *widthSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_rightPanelWidthEnabled =
        new wxCheckBox(panel, ID_RIGHT_PANEL_WIDTH_ENABLED, "Default panel width (% of window):");
    m_rightPanelWidthEnabled->SetForegroundColour(wxColour(200, 200, 200));
    m_rightPanelWidthEnabled->SetValue(true);
    m_rightPanelWidthEnabled->Bind(wxEVT_CHECKBOX, &PreferencesDialog::OnRightPanelWidthEnabledChanged, this);
    widthSizer->Add(m_rightPanelWidthEnabled, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_rightPanelWidth =
        new wxSpinCtrl(panel, wxID_ANY, "20", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 5, 80, 20);
    widthSizer->Add(m_rightPanelWidth, 0, wxALIGN_CENTER_VERTICAL);
    layoutGroup->Add(widthSizer, 0, wxEXPAND | wxALL, 5);
 
    // Minimum panel width
    wxBoxSizer *minWidthSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_rightPanelMinWidthEnabled =
        new wxCheckBox(panel, ID_RIGHT_PANEL_MIN_WIDTH_ENABLED, "Minimum panel width (% of window):");
    m_rightPanelMinWidthEnabled->SetForegroundColour(wxColour(200, 200, 200));
    m_rightPanelMinWidthEnabled->SetValue(true);
    m_rightPanelMinWidthEnabled->Bind(wxEVT_CHECKBOX, &PreferencesDialog::OnRightPanelMinWidthEnabledChanged, this);
    minWidthSizer->Add(m_rightPanelMinWidthEnabled, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_rightPanelMinWidth =
        new wxSpinCtrl(panel, wxID_ANY, "10", wxDefaultPosition, wxSize(120, -1), wxSP_ARROW_KEYS, 5, 50, 10);
    minWidthSizer->Add(m_rightPanelMinWidth, 0, wxALIGN_CENTER_VERTICAL);
    layoutGroup->Add(minWidthSizer, 0, wxEXPAND | wxALL, 5);
 
    // Show panel on startup
    wxBoxSizer *startupSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *startupLabel = new wxStaticText(panel, wxID_ANY, "On startup:");
    startupLabel->SetForegroundColour(wxColour(200, 200, 200));
    startupSizer->Add(startupLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString startupOptions;
    startupOptions.Add("Show panel");
    startupOptions.Add("Hide panel");
    startupOptions.Add("Remember last state");
    m_rightPanelStartup = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, startupOptions);
    m_rightPanelStartup->SetSelection(0);
    startupSizer->Add(m_rightPanelStartup, 1, wxEXPAND);
    layoutGroup->Add(startupSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(layoutGroup, 0, wxEXPAND | wxALL, 5);
 
    // Tab Bar group
    wxStaticBoxSizer *tabBarGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Tab Bar");
 
    m_rightPanelShowTabCloseButtons = new wxCheckBox(panel, wxID_ANY, "Show close buttons on tabs");
    m_rightPanelShowTabCloseButtons->SetForegroundColour(wxColour(200, 200, 200));
    m_rightPanelShowTabCloseButtons->SetValue(true);
    tabBarGroup->Add(m_rightPanelShowTabCloseButtons, 0, wxALL, 5);
 
    panelSizer->Add(tabBarGroup, 0, wxEXPAND | wxALL, 5);
 
    // Behavior group
    wxStaticBoxSizer *behaviorGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Behavior");
 
    m_rightPanelRememberLastTab = new wxCheckBox(panel, wxID_ANY, "Remember last active tab between sessions");
    m_rightPanelRememberLastTab->SetForegroundColour(wxColour(200, 200, 200));
    m_rightPanelRememberLastTab->SetValue(true);
    behaviorGroup->Add(m_rightPanelRememberLastTab, 0, wxALL, 5);
 
    m_rightPanelAllowCollapse = new wxCheckBox(panel, wxID_ANY, "Allow panel collapse (drag splitter to hide)");
    m_rightPanelAllowCollapse->SetForegroundColour(wxColour(200, 200, 200));
    m_rightPanelAllowCollapse->SetValue(true);
    behaviorGroup->Add(m_rightPanelAllowCollapse, 0, wxALL, 5);
 
    panelSizer->Add(behaviorGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateLogTabSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // Display Settings group
    wxStaticBoxSizer *displayGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Display Settings");
 
    // Default Level Filter
    wxBoxSizer *levelSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *levelLabel = new wxStaticText(panel, wxID_ANY, "Default level filter:");
    levelLabel->SetForegroundColour(wxColour(200, 200, 200));
    levelSizer->Add(levelLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString levelOptions;
    levelOptions.Add("All");
    levelOptions.Add("Trace");
    levelOptions.Add("Info");
    levelOptions.Add("Warning");
    levelOptions.Add("Error");
    levelOptions.Add("Critical");
    m_logDefaultLevelFilter = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, levelOptions);
    levelSizer->Add(m_logDefaultLevelFilter, 1, wxEXPAND);
    displayGroup->Add(levelSizer, 0, wxEXPAND | wxALL, 5);
 
    // Font Size
    wxBoxSizer *fontSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *fontLabel = new wxStaticText(panel, wxID_ANY, "Font size:");
    fontLabel->SetForegroundColour(wxColour(200, 200, 200));
    fontSizer->Add(fontLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString fontOptions;
    fontOptions.Add("Small");
    fontOptions.Add("Medium");
    fontOptions.Add("Large");
    m_logFontSize = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, fontOptions);
    fontSizer->Add(m_logFontSize, 1, wxEXPAND);
    displayGroup->Add(fontSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(displayGroup, 0, wxEXPAND | wxALL, 5);
 
    // Behavior Settings group
    wxStaticBoxSizer *behaviorGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Behavior Settings");
 
    // Auto-scroll enabled
    m_logAutoScrollEnabled = new wxCheckBox(panel, wxID_ANY, "Auto-scroll to newest logs");
    m_logAutoScrollEnabled->SetForegroundColour(wxColour(200, 200, 200));
    behaviorGroup->Add(m_logAutoScrollEnabled, 0, wxALL, 5);
 
    // Max log entries
    wxBoxSizer *maxEntriesSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *maxEntriesLabel = new wxStaticText(panel, wxID_ANY, "Max log entries:");
    maxEntriesLabel->SetForegroundColour(wxColour(200, 200, 200));
    maxEntriesSizer->Add(maxEntriesLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_logMaxEntries =
        new wxSpinCtrl(panel, wxID_ANY, "2000", wxDefaultPosition, wxSize(150, -1), wxSP_ARROW_KEYS, 100, 50000, 2000);
    maxEntriesSizer->Add(m_logMaxEntries, 0, wxALIGN_CENTER_VERTICAL);
 
    wxStaticText *maxEntriesHint = new wxStaticText(panel, wxID_ANY, "(100 - 50000)");
    maxEntriesHint->SetForegroundColour(wxColour(150, 150, 150));
    maxEntriesSizer->Add(maxEntriesHint, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 10);
 
    behaviorGroup->Add(maxEntriesSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(behaviorGroup, 0, wxEXPAND | wxALL, 5);
 
    // Color Settings group
    wxStaticBoxSizer *colorSettingsGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Color Settings");
 
    // Enable GUI colors
    m_logEnableGuiColors = new wxCheckBox(panel, wxID_ANY, "Enable colored text in LogTab");
    m_logEnableGuiColors->SetForegroundColour(wxColour(200, 200, 200));
    m_logEnableGuiColors->SetToolTip("Show log entries with colored text based on log level");
    colorSettingsGroup->Add(m_logEnableGuiColors, 0, wxALL, 5);
 
    // Enable console colors
    m_logEnableConsoleColors = new wxCheckBox(panel, wxID_ANY, "Enable ANSI colors in console output");
    m_logEnableConsoleColors->SetForegroundColour(wxColour(200, 200, 200));
    m_logEnableConsoleColors->SetToolTip("Enable colored output in terminal/console (via spdlog)");
    colorSettingsGroup->Add(m_logEnableConsoleColors, 0, wxALL, 5);
 
    panelSizer->Add(colorSettingsGroup, 0, wxEXPAND | wxALL, 5);
 
    // Level Colors group
    wxStaticBoxSizer *colorsGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Level Colors");
 
    // Helper lambda to create a color picker row
    auto createColorRow = [&](const wxString &label, wxColourPickerCtrl *&picker, const wxColour &defaultColor) {
        wxBoxSizer *rowSizer = new wxBoxSizer(wxHORIZONTAL);
        wxStaticText *labelText = new wxStaticText(panel, wxID_ANY, label);
        labelText->SetForegroundColour(wxColour(200, 200, 200));
        labelText->SetMinSize(wxSize(80, -1));
        rowSizer->Add(labelText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
        picker = new wxColourPickerCtrl(panel, wxID_ANY, defaultColor, wxDefaultPosition, wxSize(60, 25));
        rowSizer->Add(picker, 0, wxALIGN_CENTER_VERTICAL);
 
        colorsGroup->Add(rowSizer, 0, wxEXPAND | wxALL, 5);
    };
 
    createColorRow("Trace:", m_logTraceColor, wxColour(128, 128, 128));
    createColorRow("Info:", m_logInfoColor, wxColour(100, 200, 100));
    createColorRow("Warning:", m_logWarningColor, wxColour(230, 180, 50));
    createColorRow("Error:", m_logErrorColor, wxColour(230, 80, 80));
    createColorRow("Critical:", m_logCriticalColor, wxColour(255, 50, 50));
 
    panelSizer->Add(colorsGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreateParserSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // File Loading group
    wxStaticBoxSizer *fileGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "File Loading");
 
    m_autoLoadLastFile = new wxCheckBox(panel, ID_AUTO_LOAD_LAST_FILE, "Auto-load last opened file on startup");
    m_autoLoadLastFile->SetForegroundColour(wxColour(200, 200, 200));
    fileGroup->Add(m_autoLoadLastFile, 0, wxALL, 5);
 
    m_showParseWarnings = new wxCheckBox(panel, ID_SHOW_PARSE_WARNINGS, "Show parsing warnings");
    m_showParseWarnings->SetForegroundColour(wxColour(200, 200, 200));
    fileGroup->Add(m_showParseWarnings, 0, wxALL, 5);
 
    // File encoding
    wxBoxSizer *encodingSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *encodingLabel = new wxStaticText(panel, wxID_ANY, "Default file encoding:");
    encodingLabel->SetForegroundColour(wxColour(200, 200, 200));
    encodingSizer->Add(encodingLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString encodings;
    encodings.Add("UTF-8");
    encodings.Add("ASCII");
    encodings.Add("ISO-8859-1");
    m_fileEncoding = new wxChoice(panel, ID_FILE_ENCODING, wxDefaultPosition, wxDefaultSize, encodings);
    encodingSizer->Add(m_fileEncoding, 1, wxEXPAND);
    fileGroup->Add(encodingSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(fileGroup, 0, wxEXPAND | wxALL, 5);
 
    // Parser Configuration group
    wxStaticBoxSizer *parserGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Parser Configuration");
 
    wxStaticText *parserNote = new wxStaticText(
        panel, wxID_ANY, "For advanced parser settings including XML profiles,\nuse the parser configuration dialog:");
    parserNote->SetForegroundColour(wxColour(180, 180, 180));
    parserGroup->Add(parserNote, 0, wxALL, 5);
 
    m_configureParserButton = new wxButton(panel, ID_CONFIGURE_PARSER, "Configure Parser...");
    parserGroup->Add(m_configureParserButton, 0, wxALL | wxALIGN_CENTER, 5);
 
    panelSizer->Add(parserGroup, 0, wxEXPAND | wxALL, 5);
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
wxPanel *PreferencesDialog::CreatePerformanceSettings(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *panelSizer = new wxBoxSizer(wxVERTICAL);
 
    // === Rendering Settings ===
    wxStaticBoxSizer *renderingGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Rendering (wxWidgets-Supported)");
 
    m_enableVSync = new wxCheckBox(panel, ID_ENABLE_VSYNC, "Enable VSync");
    m_enableVSync->SetForegroundColour(wxColour(200, 200, 200));
    m_enableVSync->SetToolTip("Vertical sync for smoother rendering (OpenGL contexts only)");
    renderingGroup->Add(m_enableVSync, 0, wxALL, 5);
 
    m_hardwareAcceleration = new wxCheckBox(panel, ID_HARDWARE_ACCELERATION, "Hardware Acceleration (GPU)");
    m_hardwareAcceleration->SetForegroundColour(wxColour(200, 200, 200));
    m_hardwareAcceleration->SetToolTip("Use GPU for rendering (OpenGL contexts only, requires restart)");
    renderingGroup->Add(m_hardwareAcceleration, 0, wxALL, 5);
 
    m_enableDoubleBuffering = new wxCheckBox(panel, ID_ENABLE_DOUBLE_BUFFERING, "Double Buffering");
    m_enableDoubleBuffering->SetForegroundColour(wxColour(200, 200, 200));
    m_enableDoubleBuffering->SetToolTip("Reduce flicker using window styles (wxBUFFER_VIRTUAL_AREA)");
    renderingGroup->Add(m_enableDoubleBuffering, 0, wxALL, 5);
 
    m_enableAntiAliasing = new wxCheckBox(panel, ID_ENABLE_ANTI_ALIASING, "Graphics Anti-Aliasing");
    m_enableAntiAliasing->SetForegroundColour(wxColour(200, 200, 200));
    m_enableAntiAliasing->SetToolTip("Smooth edges using wxGraphicsContext");
    renderingGroup->Add(m_enableAntiAliasing, 0, wxALL, 5);
 
    m_enableTextAntiAliasing = new wxCheckBox(panel, ID_ENABLE_TEXT_AA, "Text Anti-Aliasing");
    m_enableTextAntiAliasing->SetForegroundColour(wxColour(200, 200, 200));
    m_enableTextAntiAliasing->SetToolTip("Smooth text using font flags");
    renderingGroup->Add(m_enableTextAntiAliasing, 0, wxALL, 5);
 
    m_enablePartialRedraws = new wxCheckBox(panel, ID_ENABLE_PARTIAL_REDRAWS, "Partial Redraws");
    m_enablePartialRedraws->SetForegroundColour(wxColour(200, 200, 200));
    m_enablePartialRedraws->SetToolTip("Only redraw changed areas (wxNO_FULL_REPAINT_ON_RESIZE)");
    renderingGroup->Add(m_enablePartialRedraws, 0, wxALL, 5);
 
    m_enableBackgroundErase = new wxCheckBox(panel, ID_ENABLE_BACKGROUND_ERASE, "Background Erase");
    m_enableBackgroundErase->SetForegroundColour(wxColour(200, 200, 200));
    m_enableBackgroundErase->SetToolTip("Erase background before redraw (disable for better performance)");
    renderingGroup->Add(m_enableBackgroundErase, 0, wxALL, 5);
 
    // FPS limit
    wxBoxSizer *fpsSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *fpsLabel = new wxStaticText(panel, wxID_ANY, "Frame Rate Limit:");
    fpsLabel->SetForegroundColour(wxColour(200, 200, 200));
    fpsSizer->Add(fpsLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    wxArrayString fpsOptions;
    fpsOptions.Add("30 FPS");
    fpsOptions.Add("60 FPS");
    fpsOptions.Add("120 FPS");
    fpsOptions.Add("Unlimited");
    m_fpsLimit = new wxChoice(panel, ID_FPS_LIMIT, wxDefaultPosition, wxSize(150, -1), fpsOptions);
    m_fpsLimit->SetToolTip("Limit frame rate using wxTimer");
    fpsSizer->Add(m_fpsLimit, 0);
    renderingGroup->Add(fpsSizer, 0, wxEXPAND | wxALL, 5);
 
    panelSizer->Add(renderingGroup, 0, wxEXPAND | wxALL, 10);
 
    // === Viewport Culling (for Large Trees) ===
    wxStaticBoxSizer *cullingGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Viewport Culling (for Large Trees)");
 
    m_enableViewportCulling = new wxCheckBox(panel, wxID_ANY, "Enable Viewport Culling");
    m_enableViewportCulling->SetForegroundColour(wxColour(200, 200, 200));
    m_enableViewportCulling->SetToolTip(
        "Only render nodes visible in viewport - major performance boost for large trees");
    cullingGroup->Add(m_enableViewportCulling, 0, wxALL, 5);
 
    // Culling margin slider
    wxBoxSizer *marginSizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText *marginLabel = new wxStaticText(panel, wxID_ANY, "Culling Margin:");
    marginLabel->SetForegroundColour(wxColour(200, 200, 200));
    marginSizer->Add(marginLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_viewportCullingMargin = new wxSpinCtrl(panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(100, -1),
                                             wxSP_ARROW_KEYS, 100, 1000, 500);
    m_viewportCullingMargin->SetToolTip(
        "Safety margin in pixels - higher values prevent edge flickering but render more off-screen nodes");
    marginSizer->Add(m_viewportCullingMargin, 0);
 
    wxStaticText *marginUnit = new wxStaticText(panel, wxID_ANY, " pixels");
    marginUnit->SetForegroundColour(wxColour(180, 180, 180));
    marginSizer->Add(marginUnit, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 5);
 
    cullingGroup->Add(marginSizer, 0, wxEXPAND | wxALL, 5);
 
    // Culling info
    wxStaticText *cullingInfo =
        new wxStaticText(panel, wxID_ANY,
                         "Viewport culling dramatically improves performance with large trees (600+ nodes)\n"
                         "by only rendering nodes visible in the current view. The margin prevents\n"
                         "flickering when nodes are at viewport edges.");
    cullingInfo->SetForegroundColour(wxColour(150, 150, 150));
    cullingGroup->Add(cullingInfo, 0, wxALL, 5);
 
    panelSizer->Add(cullingGroup, 0, wxEXPAND | wxALL, 10);
 
    // === UI Responsiveness ===
    wxStaticBoxSizer *uiGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "UI Responsiveness");
 
    m_enableIdleProcessing = new wxCheckBox(panel, ID_ENABLE_IDLE_PROCESSING, "Enable Idle Event Processing");
    m_enableIdleProcessing->SetForegroundColour(wxColour(200, 200, 200));
    m_enableIdleProcessing->SetToolTip("Process background tasks using wxIdleEvent");
    uiGroup->Add(m_enableIdleProcessing, 0, wxALL, 5);
 
    panelSizer->Add(uiGroup, 0, wxEXPAND | wxALL, 10);
 
    // Performance note
    wxStaticBoxSizer *noteGroup = new wxStaticBoxSizer(wxVERTICAL, panel, "Note");
    wxStaticText *noteText =
        new wxStaticText(panel, wxID_ANY,
                         "These settings use wxWidgets native APIs for performance tuning.\n"
                         "Some settings (VSync, Hardware Acceleration) apply only to OpenGL contexts.\n"
                         "Changes may require an application restart to take full effect.");
    noteText->SetForegroundColour(wxColour(180, 180, 180));
    noteGroup->Add(noteText, 0, wxALL, 5);
    panelSizer->Add(noteGroup, 0, wxEXPAND | wxALL, 10);
 
    panelSizer->AddStretchSpacer();
 
    panel->SetSizer(panelSizer);
    return panel;
}
 
void PreferencesDialog::ShowPanel(wxPanel *panel) {
    if (!panel)
        return;
 
    // Hide all panels
    m_windowPanel->Hide();
    m_mainPanelPanel->Hide();
    m_behaviorTreeViewPanel->Hide();
    m_bottomPanelPanel->Hide();
    m_fileExplorerPanel->Hide();
    m_logTabPanel->Hide();
    m_sidePanelPanel->Hide();
    m_leftPanelPanel->Hide();
    m_rightPanelPanel->Hide();
    m_tabsSubPanel->Hide();
    m_parserPanel->Hide();
    m_performancePanel->Hide();
 
    // Show selected panel
    panel->Show();
 
    // Update layout
    m_settingsPanel->Layout();
    m_settingsPanel->FitInside();
    m_settingsPanel->Refresh();
}
 
bool PreferencesDialog::SelectSection(const wxString &sectionName) {
    if (!m_sectionTree)
        return false;
 
    // Helper lambda to recursively find and select a tree item by name
    std::function<bool(wxTreeItemId)> findAndSelect = [&](wxTreeItemId item) -> bool {
        if (!item.IsOk())
            return false;
 
        if (m_sectionTree->GetItemText(item) == sectionName) {
            m_sectionTree->SelectItem(item);
            m_sectionTree->EnsureVisible(item);
 
            // Also show the corresponding panel
            SectionTreeItemData *data = dynamic_cast<SectionTreeItemData *>(m_sectionTree->GetItemData(item));
            if (data && data->GetPanel()) {
                ShowPanel(data->GetPanel());
            }
            return true;
        }
 
        // Check children
        wxTreeItemIdValue cookie;
        wxTreeItemId child = m_sectionTree->GetFirstChild(item, cookie);
        while (child.IsOk()) {
            if (findAndSelect(child))
                return true;
            child = m_sectionTree->GetNextChild(item, cookie);
        }
        return false;
    };
 
    // Start from root
    wxTreeItemId rootId = m_sectionTree->GetRootItem();
    return findAndSelect(rootId);
}
 
void PreferencesDialog::LoadCurrentSettings() {
    using namespace EmberForge;
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
 
    // Window settings
    m_themeChoice->SetSelection(static_cast<int>(prefs.GetWindowSettings().theme));
    wxColour accentColor(prefs.GetWindowSettings().accentColor.r, prefs.GetWindowSettings().accentColor.g,
                         prefs.GetWindowSettings().accentColor.b);
    m_accentColorPicker->SetColour(accentColor);
    m_startupModeChoice->SetSelection(static_cast<int>(prefs.GetWindowSettings().startupMode));
 
    // File menu hotkeys
    m_newProjectHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().newProjectHotkey));
    m_openProjectHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().openProjectHotkey));
    m_openFileHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().openFileHotkey));
    m_saveHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().saveHotkey));
    m_saveAsHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().saveAsHotkey));
 
    // View menu hotkeys
    m_maximizeHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().maximizeHotkey));
    m_resetUIHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().resetUIHotkey));
 
    // Settings menu hotkeys
    m_preferencesHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().preferencesHotkey));
    m_parserConfigHotkeyTextCtrl->SetValue(wxString(prefs.GetWindowSettings().parserConfigHotkey));
 
    // Window appearance
    m_showStatusBar->SetValue(prefs.GetWindowSettings().showStatusBar);
    m_showPanelCaptions->SetValue(prefs.GetWindowSettings().showPanelCaptions);
    m_alwaysOnTop->SetValue(prefs.GetWindowSettings().alwaysOnTop);
 
    // Window constraints
    m_minWindowWidth->SetValue(prefs.GetWindowSettings().minWindowWidthPct);
    m_minWindowHeight->SetValue(prefs.GetWindowSettings().minWindowHeightPct);
    bool maxUnlimited =
        (prefs.GetWindowSettings().maxWindowWidthPct == -1 || prefs.GetWindowSettings().maxWindowHeightPct == -1);
    m_maxWindowUnlimited->SetValue(maxUnlimited);
    m_maxWindowWidth->SetValue(prefs.GetWindowSettings().maxWindowWidthPct);
    m_maxWindowHeight->SetValue(prefs.GetWindowSettings().maxWindowHeightPct);
    m_maxWindowWidth->Enable(!maxUnlimited);
    m_maxWindowHeight->Enable(!maxUnlimited);
 
    m_enforceAspectRatio->SetValue(prefs.GetWindowSettings().enforceAspectRatio);
    // Parse aspect ratio from float
    float ratio = prefs.GetWindowSettings().aspectRatio;
    // Common ratios: 16:9 = 1.777..., 4:3 = 1.333..., 21:9 = 2.333...
    int width = 16, height = 9;
    if (std::abs(ratio - 16.0f / 9.0f) < 0.01f) {
        width = 16;
        height = 9;
    } else if (std::abs(ratio - 4.0f / 3.0f) < 0.01f) {
        width = 4;
        height = 3;
    } else if (std::abs(ratio - 21.0f / 9.0f) < 0.01f) {
        width = 21;
        height = 9;
    }
    m_aspectRatioWidth->SetValue(wxString::Format("%d", width));
    m_aspectRatioHeight->SetValue(wxString::Format("%d", height));
 
    // Main panel settings
    int zoomPercent = static_cast<int>(prefs.GetMainPanelSettings().defaultZoomLevel * 100);
    m_defaultZoomSlider->SetValue(zoomPercent);
    m_zoomLabel->SetLabel(wxString::Format("%d%%", zoomPercent));
    m_showGrid->SetValue(prefs.GetMainPanelSettings().showGrid);
    m_gridSize->SetValue(prefs.GetMainPanelSettings().gridSize);
    wxColour gridBg(prefs.GetMainPanelSettings().gridBackgroundColor.r,
                    prefs.GetMainPanelSettings().gridBackgroundColor.g,
                    prefs.GetMainPanelSettings().gridBackgroundColor.b);
    m_gridBackgroundPicker->SetColour(gridBg);
    wxColour gridLineColor(prefs.GetMainPanelSettings().gridLineColor.r, prefs.GetMainPanelSettings().gridLineColor.g,
                           prefs.GetMainPanelSettings().gridLineColor.b);
    m_gridLineColorPicker->SetColour(gridLineColor);
    wxColour canvasBg(prefs.GetMainPanelSettings().canvasBackgroundColor.r,
                      prefs.GetMainPanelSettings().canvasBackgroundColor.g,
                      prefs.GetMainPanelSettings().canvasBackgroundColor.b);
    m_canvasBackgroundPicker->SetColour(canvasBg);
    wxColour connectionLineColor(prefs.GetMainPanelSettings().connectionLineColor.r,
                                 prefs.GetMainPanelSettings().connectionLineColor.g,
                                 prefs.GetMainPanelSettings().connectionLineColor.b);
    m_connectionLineColorPicker->SetColour(connectionLineColor);
    m_highlightPathToSelected->SetValue(prefs.GetMainPanelSettings().highlightPathToSelected);
    wxColour pathHighlightColor(prefs.GetMainPanelSettings().pathHighlightColor.r,
                                prefs.GetMainPanelSettings().pathHighlightColor.g,
                                prefs.GetMainPanelSettings().pathHighlightColor.b);
    m_pathHighlightColorPicker->SetColour(pathHighlightColor);
    wxColour idleNodeBg(prefs.GetMainPanelSettings().idleNodeBgColor.r, prefs.GetMainPanelSettings().idleNodeBgColor.g,
                        prefs.GetMainPanelSettings().idleNodeBgColor.b);
    m_idleNodeBgColorPicker->SetColour(idleNodeBg);
    wxColour idleNodeBorder(prefs.GetMainPanelSettings().idleNodeBorderColor.r,
                            prefs.GetMainPanelSettings().idleNodeBorderColor.g,
                            prefs.GetMainPanelSettings().idleNodeBorderColor.b);
    m_idleNodeBorderColorPicker->SetColour(idleNodeBorder);
    wxColour idleNodeText(prefs.GetMainPanelSettings().idleNodeTextColor.r,
                          prefs.GetMainPanelSettings().idleNodeTextColor.g,
                          prefs.GetMainPanelSettings().idleNodeTextColor.b);
    m_idleNodeTextColorPicker->SetColour(idleNodeText);
    int selectedTint = static_cast<int>(prefs.GetMainPanelSettings().selectedNodeBgTint * 100);
    m_selectedNodeBgTint->SetValue(selectedTint);
    m_selectedNodeBgTintLabel->SetLabel(wxString::Format("%d%%", selectedTint));
    int hoveredTint = static_cast<int>(prefs.GetMainPanelSettings().hoveredNodeBgTint * 100);
    m_hoveredNodeBgTint->SetValue(hoveredTint);
    m_hoveredNodeBgTintLabel->SetLabel(wxString::Format("%d%%", hoveredTint));
    wxColour selectedNode(prefs.GetMainPanelSettings().selectedNodeColor.r,
                          prefs.GetMainPanelSettings().selectedNodeColor.g,
                          prefs.GetMainPanelSettings().selectedNodeColor.b);
    m_selectedNodeColorPicker->SetColour(selectedNode);
    wxColour hoveredNode(prefs.GetMainPanelSettings().hoveredNodeColor.r,
                         prefs.GetMainPanelSettings().hoveredNodeColor.g,
                         prefs.GetMainPanelSettings().hoveredNodeColor.b);
    m_hoveredNodeColorPicker->SetColour(hoveredNode);
    wxColour selectedNodeText(prefs.GetMainPanelSettings().selectedNodeTextColor.r,
                              prefs.GetMainPanelSettings().selectedNodeTextColor.g,
                              prefs.GetMainPanelSettings().selectedNodeTextColor.b);
    m_selectedNodeTextColorPicker->SetColour(selectedNodeText);
    wxColour hoveredNodeText(prefs.GetMainPanelSettings().hoveredNodeTextColor.r,
                             prefs.GetMainPanelSettings().hoveredNodeTextColor.g,
                             prefs.GetMainPanelSettings().hoveredNodeTextColor.b);
    m_hoveredNodeTextColorPicker->SetColour(hoveredNodeText);
    wxColour selectedNodeInfo(prefs.GetMainPanelSettings().selectedNodeInfoColor.r,
                              prefs.GetMainPanelSettings().selectedNodeInfoColor.g,
                              prefs.GetMainPanelSettings().selectedNodeInfoColor.b);
    m_selectedNodeInfoColorPicker->SetColour(selectedNodeInfo);
    wxColour hoveredNodeInfo(prefs.GetMainPanelSettings().hoveredNodeInfoColor.r,
                             prefs.GetMainPanelSettings().hoveredNodeInfoColor.g,
                             prefs.GetMainPanelSettings().hoveredNodeInfoColor.b);
    m_hoveredNodeInfoColorPicker->SetColour(hoveredNodeInfo);
 
    // Scene management
    bool scenesUnlimited = (prefs.GetMainPanelSettings().maxScenes == -1);
    m_maxScenesUnlimited->SetValue(scenesUnlimited);
    m_maxScenes->SetValue(prefs.GetMainPanelSettings().maxScenes > 0 ? prefs.GetMainPanelSettings().maxScenes : 10);
    m_maxScenes->Enable(!scenesUnlimited);
 
    m_closeConfirmation->SetSelection(static_cast<int>(prefs.GetMainPanelSettings().closeConfirmation));
 
    m_nextSceneHotkeyTextCtrl->SetValue(wxString(prefs.GetMainPanelSettings().nextSceneHotkey));
    m_previousSceneHotkeyTextCtrl->SetValue(wxString(prefs.GetMainPanelSettings().previousSceneHotkey));
 
    // Behavior tree view settings
    const auto &btViewSettings = prefs.GetBehaviorTreeViewSettings();
 
    // Convert zoom step size from float (0.0-1.0) to percentage (1-50)
    int zoomStepPercent = static_cast<int>(btViewSettings.zoomStepSize * 100);
    m_zoomStepSize->SetValue(zoomStepPercent);
    m_zoomStepSizeLabel->SetLabel(wxString::Format("%d%%", zoomStepPercent));
 
    int wheelSensitivity = static_cast<int>(btViewSettings.mouseWheelSensitivity * 100);
    m_mouseWheelSensitivity->SetValue(wheelSensitivity);
    m_mouseWheelSensitivityLabel->SetLabel(wxString::Format("%.1fx", btViewSettings.mouseWheelSensitivity));
 
    m_zoomFollowsCursor->SetValue(btViewSettings.zoomFollowsCursor);
    m_resetViewHotkeyTextCtrl->SetValue(wxString(btViewSettings.resetViewHotkey));
 
    int panSensitivity = static_cast<int>(btViewSettings.panSensitivity * 100);
    m_panSensitivity->SetValue(panSensitivity);
    m_panSensitivityLabel->SetLabel(wxString::Format("%.1fx", btViewSettings.panSensitivity));
 
    m_panKeyTextCtrl->SetValue(wxString(btViewSettings.panKey));
    m_enableSmoothPanning->SetValue(btViewSettings.enableSmoothPanning);
    m_panSmoothness->SetValue(static_cast<int>(btViewSettings.panSmoothness));
    m_panSmoothnessLabel->SetLabel(wxString::Format("%d%%", static_cast<int>(btViewSettings.panSmoothness)));
    m_panStepSize->SetValue(static_cast<int>(btViewSettings.panStepSize));
    m_panStepSizeLabel->SetLabel(wxString::Format("%dpx", static_cast<int>(btViewSettings.panStepSize)));
    m_centerOnNodeHotkeyTextCtrl->SetValue(wxString(btViewSettings.centerOnNodeHotkey));
    m_deleteNodeHotkeyTextCtrl->SetValue(wxString(btViewSettings.deleteNodeHotkey));
    m_panUpHotkeyTextCtrl->SetValue(wxString(btViewSettings.panUpHotkey));
    m_panDownHotkeyTextCtrl->SetValue(wxString(btViewSettings.panDownHotkey));
    m_panLeftHotkeyTextCtrl->SetValue(wxString(btViewSettings.panLeftHotkey));
    m_panRightHotkeyTextCtrl->SetValue(wxString(btViewSettings.panRightHotkey));
 
    // Debug text settings - Coordinate System Info
    if (m_showCoordinateInfo)
        m_showCoordinateInfo->SetValue(btViewSettings.showCoordinateInfo);
    if (m_coordinateInfoFontSize)
        m_coordinateInfoFontSize->SetValue(btViewSettings.coordinateInfoFontSize);
    if (m_coordinateInfoColorPicker)
        m_coordinateInfoColorPicker->SetColour(wxColour(btViewSettings.coordinateInfoColor.r,
                                                        btViewSettings.coordinateInfoColor.g,
                                                        btViewSettings.coordinateInfoColor.b));
    if (m_coordinateInfoAnchor)
        m_coordinateInfoAnchor->SetSelection(static_cast<int>(btViewSettings.coordinateInfoAnchor));
    if (m_coordinateInfoX)
        m_coordinateInfoX->SetValue(btViewSettings.coordinateInfoX);
    if (m_coordinateInfoY)
        m_coordinateInfoY->SetValue(btViewSettings.coordinateInfoY);
 
    // Debug text settings - Selected Node Info
    if (m_showSelectedNodeInfo)
        m_showSelectedNodeInfo->SetValue(btViewSettings.showSelectedNodeInfo);
    if (m_selectedNodeInfoFontSize)
        m_selectedNodeInfoFontSize->SetValue(btViewSettings.selectedNodeInfoFontSize);
    if (m_selectedNodeDebugInfoColorPicker)
        m_selectedNodeDebugInfoColorPicker->SetColour(wxColour(btViewSettings.selectedNodeInfoColor.r,
                                                               btViewSettings.selectedNodeInfoColor.g,
                                                               btViewSettings.selectedNodeInfoColor.b));
    if (m_selectedNodeInfoAnchor)
        m_selectedNodeInfoAnchor->SetSelection(static_cast<int>(btViewSettings.selectedNodeInfoAnchor));
    if (m_selectedNodeInfoX)
        m_selectedNodeInfoX->SetValue(btViewSettings.selectedNodeInfoX);
    if (m_selectedNodeInfoY)
        m_selectedNodeInfoY->SetValue(btViewSettings.selectedNodeInfoY);
 
    // Debug text settings - Tree Statistics Info
    if (m_showTreeInfo)
        m_showTreeInfo->SetValue(btViewSettings.showTreeInfo);
    if (m_treeInfoFontSize)
        m_treeInfoFontSize->SetValue(btViewSettings.treeInfoFontSize);
    if (m_treeInfoColorPicker)
        m_treeInfoColorPicker->SetColour(
            wxColour(btViewSettings.treeInfoColor.r, btViewSettings.treeInfoColor.g, btViewSettings.treeInfoColor.b));
    if (m_treeInfoAnchor)
        m_treeInfoAnchor->SetSelection(static_cast<int>(btViewSettings.treeInfoAnchor));
    if (m_treeInfoX)
        m_treeInfoX->SetValue(btViewSettings.treeInfoX);
    if (m_treeInfoY)
        m_treeInfoY->SetValue(btViewSettings.treeInfoY);
 
    // Debug text settings - FPS Display
    if (m_showFPS)
        m_showFPS->SetValue(btViewSettings.showFPS);
    if (m_fpsFontSize)
        m_fpsFontSize->SetValue(btViewSettings.fpsFontSize);
    if (m_fpsColorPicker)
        m_fpsColorPicker->SetColour(
            wxColour(btViewSettings.fpsColor.r, btViewSettings.fpsColor.g, btViewSettings.fpsColor.b));
    if (m_fpsAnchor)
        m_fpsAnchor->SetSelection(static_cast<int>(btViewSettings.fpsAnchor));
    if (m_fpsX)
        m_fpsX->SetValue(btViewSettings.fpsX);
    if (m_fpsY)
        m_fpsY->SetValue(btViewSettings.fpsY);
 
    // Debug text settings - Controls Help Text
    if (m_showControlsHelp)
        m_showControlsHelp->SetValue(btViewSettings.showControlsHelp);
    if (m_controlsHelpFontSize)
        m_controlsHelpFontSize->SetValue(btViewSettings.controlsHelpFontSize);
    if (m_controlsHelpColorPicker)
        m_controlsHelpColorPicker->SetColour(wxColour(btViewSettings.controlsHelpColor.r,
                                                      btViewSettings.controlsHelpColor.g,
                                                      btViewSettings.controlsHelpColor.b));
    if (m_controlsHelpAnchor)
        m_controlsHelpAnchor->SetSelection(static_cast<int>(btViewSettings.controlsHelpAnchor));
    if (m_controlsHelpX)
        m_controlsHelpX->SetValue(btViewSettings.controlsHelpX);
    if (m_controlsHelpY)
        m_controlsHelpY->SetValue(btViewSettings.controlsHelpY);
 
    // Bottom panel container settings
    const auto &bottomSettings = prefs.GetBottomPanelSettings();
    m_bottomPanelHeight->SetValue(bottomSettings.defaultPanelHeightPct);
    m_bottomPanelHeightEnabled->SetValue(bottomSettings.defaultPanelHeightEnabled);
    m_bottomPanelHeight->Enable(bottomSettings.defaultPanelHeightEnabled);
    m_bottomPanelMinHeight->SetValue(bottomSettings.minimumPanelHeightPct);
    m_bottomPanelMinHeightEnabled->SetValue(bottomSettings.minimumPanelHeightEnabled);
    m_bottomPanelMinHeight->Enable(bottomSettings.minimumPanelHeightEnabled);
    m_bottomPanelStartup->SetSelection(static_cast<int>(bottomSettings.panelStartupState));
    m_showTabCloseButtons->SetValue(bottomSettings.showTabCloseButtons);
    m_rememberLastTab->SetValue(bottomSettings.rememberLastTab);
    m_allowPanelCollapse->SetValue(bottomSettings.allowPanelCollapse);
 
    // File Explorer tab general settings
    m_showBreadcrumb->SetValue(bottomSettings.showBreadcrumb);
    m_showHistory->SetValue(bottomSettings.showHistory);
 
    // Start Path Mode
    int startPathModeIndex = static_cast<int>(bottomSettings.startPathMode);
    m_startPathMode->SetSelection(startPathModeIndex);
    m_customStartPath->SetValue(wxString(bottomSettings.customStartPath));
    bool enableCustomPath = (startPathModeIndex == 1); // CustomPath (second option)
    m_customStartPath->Enable(enableCustomPath);
    m_browseStartPath->Enable(enableCustomPath);
 
    // Tree View settings
    m_treeShowHiddenFiles->SetValue(bottomSettings.treeView.showHiddenFiles);
    m_treeShowFileExtensions->SetValue(bottomSettings.treeView.showFileExtensions);
    m_treeSortFilesBy->SetSelection(static_cast<int>(bottomSettings.treeView.sortFilesBy));
 
    // Tree Item Size
    int treeItemSizeIndex = 1; // Default to Medium
    switch (bottomSettings.treeView.itemSize) {
    case AppPreferences::TreeItemSize::Small:
        treeItemSizeIndex = 0;
        break;
    case AppPreferences::TreeItemSize::Medium:
        treeItemSizeIndex = 1;
        break;
    case AppPreferences::TreeItemSize::Large:
        treeItemSizeIndex = 2;
        break;
    }
    m_treeItemSize->SetSelection(treeItemSizeIndex);
 
    // Grid View settings
    m_gridShowHiddenFiles->SetValue(bottomSettings.gridView.showHiddenFiles);
    m_gridShowFileExtensions->SetValue(bottomSettings.gridView.showFileExtensions);
    m_gridSortFilesBy->SetSelection(static_cast<int>(bottomSettings.gridView.sortFilesBy));
 
    // Icon Size
    int iconSizeIndex = 1; // Default to Medium
    switch (bottomSettings.gridView.iconSize) {
    case AppPreferences::IconSize::Small:
        iconSizeIndex = 0;
        break;
    case AppPreferences::IconSize::Medium:
        iconSizeIndex = 1;
        break;
    case AppPreferences::IconSize::Large:
        iconSizeIndex = 2;
        break;
    }
    m_gridIconSize->SetSelection(iconSizeIndex);
 
    // Log Tab settings
    m_logDefaultLevelFilter->SetSelection(bottomSettings.logTab.defaultLevelFilter);
    m_logAutoScrollEnabled->SetValue(bottomSettings.logTab.autoScrollEnabled);
    m_logMaxEntries->SetValue(bottomSettings.logTab.maxLogEntries);
    m_logEnableGuiColors->SetValue(bottomSettings.logTab.enableGuiColors);
    m_logEnableConsoleColors->SetValue(bottomSettings.logTab.enableConsoleColors);
 
    int logFontSizeIndex = 1; // Default to Medium
    switch (bottomSettings.logTab.fontSize) {
    case AppPreferences::LogFontSize::Small:
        logFontSizeIndex = 0;
        break;
    case AppPreferences::LogFontSize::Medium:
        logFontSizeIndex = 1;
        break;
    case AppPreferences::LogFontSize::Large:
        logFontSizeIndex = 2;
        break;
    }
    m_logFontSize->SetSelection(logFontSizeIndex);
 
    // Log level colors
    m_logTraceColor->SetColour(wxColour(bottomSettings.logTab.traceColor.r, bottomSettings.logTab.traceColor.g,
                                        bottomSettings.logTab.traceColor.b));
    m_logInfoColor->SetColour(wxColour(bottomSettings.logTab.infoColor.r, bottomSettings.logTab.infoColor.g,
                                       bottomSettings.logTab.infoColor.b));
    m_logWarningColor->SetColour(wxColour(bottomSettings.logTab.warningColor.r, bottomSettings.logTab.warningColor.g,
                                          bottomSettings.logTab.warningColor.b));
    m_logErrorColor->SetColour(wxColour(bottomSettings.logTab.errorColor.r, bottomSettings.logTab.errorColor.g,
                                        bottomSettings.logTab.errorColor.b));
    m_logCriticalColor->SetColour(wxColour(bottomSettings.logTab.criticalColor.r, bottomSettings.logTab.criticalColor.g,
                                           bottomSettings.logTab.criticalColor.b));
 
    // Left Panel Settings
    const auto &leftSettings = prefs.GetLeftPanelSettings();
    m_leftPanelWidthEnabled->SetValue(leftSettings.defaultPanelWidthEnabled);
    m_leftPanelWidth->SetValue(leftSettings.defaultPanelWidthPct);
    m_leftPanelWidth->Enable(leftSettings.defaultPanelWidthEnabled);
    m_leftPanelMinWidthEnabled->SetValue(leftSettings.minimumPanelWidthEnabled);
    m_leftPanelMinWidth->SetValue(leftSettings.minimumPanelWidthPct);
    m_leftPanelMinWidth->Enable(leftSettings.minimumPanelWidthEnabled);
 
    int leftPanelStartupIndex = 0;
    switch (leftSettings.panelStartupState) {
    case AppPreferences::PanelStartupState::Show:
        leftPanelStartupIndex = 0;
        break;
    case AppPreferences::PanelStartupState::Hide:
        leftPanelStartupIndex = 1;
        break;
    case AppPreferences::PanelStartupState::RememberLast:
        leftPanelStartupIndex = 2;
        break;
    }
    m_leftPanelStartup->SetSelection(leftPanelStartupIndex);
 
    m_leftPanelShowTabCloseButtons->SetValue(leftSettings.showTabCloseButtons);
    m_leftPanelRememberLastTab->SetValue(leftSettings.rememberLastTab);
    m_leftPanelAllowCollapse->SetValue(leftSettings.allowPanelCollapse);
 
    // Right Panel Settings
    const auto &rightSettings = prefs.GetRightPanelSettings();
    m_rightPanelWidthEnabled->SetValue(rightSettings.defaultPanelWidthEnabled);
    m_rightPanelWidth->SetValue(rightSettings.defaultPanelWidthPct);
    m_rightPanelWidth->Enable(rightSettings.defaultPanelWidthEnabled);
    m_rightPanelMinWidthEnabled->SetValue(rightSettings.minimumPanelWidthEnabled);
    m_rightPanelMinWidth->SetValue(rightSettings.minimumPanelWidthPct);
    m_rightPanelMinWidth->Enable(rightSettings.minimumPanelWidthEnabled);
 
    int rightPanelStartupIndex = 0;
    switch (rightSettings.panelStartupState) {
    case AppPreferences::PanelStartupState::Show:
        rightPanelStartupIndex = 0;
        break;
    case AppPreferences::PanelStartupState::Hide:
        rightPanelStartupIndex = 1;
        break;
    case AppPreferences::PanelStartupState::RememberLast:
        rightPanelStartupIndex = 2;
        break;
    }
    m_rightPanelStartup->SetSelection(rightPanelStartupIndex);
 
    m_rightPanelShowTabCloseButtons->SetValue(rightSettings.showTabCloseButtons);
    m_rightPanelRememberLastTab->SetValue(rightSettings.rememberLastTab);
    m_rightPanelAllowCollapse->SetValue(rightSettings.allowPanelCollapse);
 
    // Parser settings
    m_autoLoadLastFile->SetValue(prefs.GetParserSettings().autoLoadLastFile);
    m_showParseWarnings->SetValue(prefs.GetParserSettings().showParseWarnings);
 
    // Find encoding in list
    wxString encoding = prefs.GetParserSettings().defaultFileEncoding;
    int encodingIdx = m_fileEncoding->FindString(encoding);
    if (encodingIdx != wxNOT_FOUND) {
        m_fileEncoding->SetSelection(encodingIdx);
    } else {
        m_fileEncoding->SetSelection(0); // Default to UTF-8
    }
 
    // Performance settings
    m_enableVSync->SetValue(prefs.GetPerformanceSettings().enableVSync);
    m_hardwareAcceleration->SetValue(prefs.GetPerformanceSettings().hardwareAcceleration);
    m_enableDoubleBuffering->SetValue(prefs.GetPerformanceSettings().enableDoubleBuffering);
    m_enableAntiAliasing->SetValue(prefs.GetPerformanceSettings().enableAntiAliasing);
    m_enableTextAntiAliasing->SetValue(prefs.GetPerformanceSettings().enableTextAntiAliasing);
    m_enablePartialRedraws->SetValue(prefs.GetPerformanceSettings().enablePartialRedraws);
    m_enableBackgroundErase->SetValue(prefs.GetPerformanceSettings().enableBackgroundErase);
    m_enableViewportCulling->SetValue(prefs.GetPerformanceSettings().enableViewportCulling);
    m_viewportCullingMargin->SetValue(prefs.GetPerformanceSettings().viewportCullingMargin);
    m_fpsLimit->SetSelection(static_cast<int>(prefs.GetPerformanceSettings().fpsLimit));
    m_enableIdleProcessing->SetValue(prefs.GetPerformanceSettings().enableIdleProcessing);
}
 
void PreferencesDialog::ApplySettings() {
    using namespace EmberForge;
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
 
    // Window settings
    prefs.GetWindowSettings().theme = static_cast<AppPreferences::ThemeMode>(m_themeChoice->GetSelection());
    wxColour accentColor = m_accentColorPicker->GetColour();
    prefs.GetWindowSettings().accentColor =
        EmberCore::Color(accentColor.Red(), accentColor.Green(), accentColor.Blue());
    prefs.GetWindowSettings().startupMode =
        static_cast<AppPreferences::StartupMode>(m_startupModeChoice->GetSelection());
 
    // File menu hotkeys
    prefs.GetWindowSettings().newProjectHotkey = m_newProjectHotkeyTextCtrl->GetValue().ToStdString();
    prefs.GetWindowSettings().openProjectHotkey = m_openProjectHotkeyTextCtrl->GetValue().ToStdString();
    prefs.GetWindowSettings().openFileHotkey = m_openFileHotkeyTextCtrl->GetValue().ToStdString();
    prefs.GetWindowSettings().saveHotkey = m_saveHotkeyTextCtrl->GetValue().ToStdString();
    prefs.GetWindowSettings().saveAsHotkey = m_saveAsHotkeyTextCtrl->GetValue().ToStdString();
 
    // View menu hotkeys
    prefs.GetWindowSettings().maximizeHotkey = m_maximizeHotkeyTextCtrl->GetValue().ToStdString();
    prefs.GetWindowSettings().resetUIHotkey = m_resetUIHotkeyTextCtrl->GetValue().ToStdString();
 
    // Settings menu hotkeys
    prefs.GetWindowSettings().preferencesHotkey = m_preferencesHotkeyTextCtrl->GetValue().ToStdString();
    prefs.GetWindowSettings().parserConfigHotkey = m_parserConfigHotkeyTextCtrl->GetValue().ToStdString();
 
    // Window appearance
    prefs.GetWindowSettings().showStatusBar = m_showStatusBar->GetValue();
    prefs.GetWindowSettings().showPanelCaptions = m_showPanelCaptions->GetValue();
    prefs.GetWindowSettings().alwaysOnTop = m_alwaysOnTop->GetValue();
 
    // Window constraints (percentage of screen)
    prefs.GetWindowSettings().minWindowWidthPct = m_minWindowWidth->GetValue();
    prefs.GetWindowSettings().minWindowHeightPct = m_minWindowHeight->GetValue();
    if (m_maxWindowUnlimited->GetValue()) {
        prefs.GetWindowSettings().maxWindowWidthPct = -1;
        prefs.GetWindowSettings().maxWindowHeightPct = -1;
    } else {
        prefs.GetWindowSettings().maxWindowWidthPct = m_maxWindowWidth->GetValue();
        prefs.GetWindowSettings().maxWindowHeightPct = m_maxWindowHeight->GetValue();
    }
    prefs.GetWindowSettings().enforceAspectRatio = m_enforceAspectRatio->GetValue();
 
    // Parse aspect ratio from text fields
    long widthVal = 16, heightVal = 9;
    m_aspectRatioWidth->GetValue().ToLong(&widthVal);
    m_aspectRatioHeight->GetValue().ToLong(&heightVal);
    if (heightVal > 0) {
        prefs.GetWindowSettings().aspectRatio = static_cast<float>(widthVal) / static_cast<float>(heightVal);
    }
 
    // Main panel settings
    prefs.GetMainPanelSettings().defaultZoomLevel = m_defaultZoomSlider->GetValue() / 100.0f;
    prefs.GetMainPanelSettings().showGrid = m_showGrid->GetValue();
    prefs.GetMainPanelSettings().gridSize = m_gridSize->GetValue();
    wxColour gridBg = m_gridBackgroundPicker->GetColour();
    prefs.GetMainPanelSettings().gridBackgroundColor = EmberCore::Color(gridBg.Red(), gridBg.Green(), gridBg.Blue());
    wxColour gridLineColor = m_gridLineColorPicker->GetColour();
    prefs.GetMainPanelSettings().gridLineColor =
        EmberCore::Color(gridLineColor.Red(), gridLineColor.Green(), gridLineColor.Blue());
    wxColour canvasBg = m_canvasBackgroundPicker->GetColour();
    prefs.GetMainPanelSettings().canvasBackgroundColor =
        EmberCore::Color(canvasBg.Red(), canvasBg.Green(), canvasBg.Blue());
    wxColour connectionLineColor = m_connectionLineColorPicker->GetColour();
    prefs.GetMainPanelSettings().connectionLineColor =
        EmberCore::Color(connectionLineColor.Red(), connectionLineColor.Green(), connectionLineColor.Blue());
    prefs.GetMainPanelSettings().highlightPathToSelected = m_highlightPathToSelected->GetValue();
    wxColour pathHighlightColor = m_pathHighlightColorPicker->GetColour();
    prefs.GetMainPanelSettings().pathHighlightColor =
        EmberCore::Color(pathHighlightColor.Red(), pathHighlightColor.Green(), pathHighlightColor.Blue());
    wxColour idleNodeBg = m_idleNodeBgColorPicker->GetColour();
    prefs.GetMainPanelSettings().idleNodeBgColor =
        EmberCore::Color(idleNodeBg.Red(), idleNodeBg.Green(), idleNodeBg.Blue());
    wxColour idleNodeBorder = m_idleNodeBorderColorPicker->GetColour();
    prefs.GetMainPanelSettings().idleNodeBorderColor =
        EmberCore::Color(idleNodeBorder.Red(), idleNodeBorder.Green(), idleNodeBorder.Blue());
    wxColour idleNodeText = m_idleNodeTextColorPicker->GetColour();
    prefs.GetMainPanelSettings().idleNodeTextColor =
        EmberCore::Color(idleNodeText.Red(), idleNodeText.Green(), idleNodeText.Blue());
    prefs.GetMainPanelSettings().selectedNodeBgTint = m_selectedNodeBgTint->GetValue() / 100.0f;
    prefs.GetMainPanelSettings().hoveredNodeBgTint = m_hoveredNodeBgTint->GetValue() / 100.0f;
    wxColour selectedNode = m_selectedNodeColorPicker->GetColour();
    prefs.GetMainPanelSettings().selectedNodeColor =
        EmberCore::Color(selectedNode.Red(), selectedNode.Green(), selectedNode.Blue());
    wxColour hoveredNode = m_hoveredNodeColorPicker->GetColour();
    prefs.GetMainPanelSettings().hoveredNodeColor =
        EmberCore::Color(hoveredNode.Red(), hoveredNode.Green(), hoveredNode.Blue());
    wxColour selectedNodeText = m_selectedNodeTextColorPicker->GetColour();
    prefs.GetMainPanelSettings().selectedNodeTextColor =
        EmberCore::Color(selectedNodeText.Red(), selectedNodeText.Green(), selectedNodeText.Blue());
    wxColour hoveredNodeText = m_hoveredNodeTextColorPicker->GetColour();
    prefs.GetMainPanelSettings().hoveredNodeTextColor =
        EmberCore::Color(hoveredNodeText.Red(), hoveredNodeText.Green(), hoveredNodeText.Blue());
    wxColour selectedNodeInfo = m_selectedNodeInfoColorPicker->GetColour();
    prefs.GetMainPanelSettings().selectedNodeInfoColor =
        EmberCore::Color(selectedNodeInfo.Red(), selectedNodeInfo.Green(), selectedNodeInfo.Blue());
    wxColour hoveredNodeInfo = m_hoveredNodeInfoColorPicker->GetColour();
    prefs.GetMainPanelSettings().hoveredNodeInfoColor =
        EmberCore::Color(hoveredNodeInfo.Red(), hoveredNodeInfo.Green(), hoveredNodeInfo.Blue());
 
    // Scene management
    if (m_maxScenesUnlimited->GetValue()) {
        prefs.GetMainPanelSettings().maxScenes = -1;
    } else {
        prefs.GetMainPanelSettings().maxScenes = m_maxScenes->GetValue();
    }
 
    prefs.GetMainPanelSettings().closeConfirmation =
        static_cast<AppPreferences::CloseConfirmationMode>(m_closeConfirmation->GetSelection());
 
    prefs.GetMainPanelSettings().nextSceneHotkey = m_nextSceneHotkeyTextCtrl->GetValue().ToStdString();
    prefs.GetMainPanelSettings().previousSceneHotkey = m_previousSceneHotkeyTextCtrl->GetValue().ToStdString();
 
    // Behavior tree view settings
    auto &btViewSettings = prefs.GetBehaviorTreeViewSettings();
 
    // Convert zoom step size from percentage (1-50) to float (0.01-0.5)
    btViewSettings.zoomStepSize = m_zoomStepSize->GetValue() / 100.0f;
 
    btViewSettings.mouseWheelSensitivity = m_mouseWheelSensitivity->GetValue() / 100.0f;
    btViewSettings.zoomFollowsCursor = m_zoomFollowsCursor->GetValue();
    btViewSettings.resetViewHotkey = m_resetViewHotkeyTextCtrl->GetValue().ToStdString();
    btViewSettings.panSensitivity = m_panSensitivity->GetValue() / 100.0f;
    btViewSettings.panKey = m_panKeyTextCtrl->GetValue().ToStdString();
    btViewSettings.enableSmoothPanning = m_enableSmoothPanning->GetValue();
    btViewSettings.panSmoothness = static_cast<float>(m_panSmoothness->GetValue());
    btViewSettings.panStepSize = static_cast<float>(m_panStepSize->GetValue());
    btViewSettings.centerOnNodeHotkey = m_centerOnNodeHotkeyTextCtrl->GetValue().ToStdString();
    btViewSettings.deleteNodeHotkey = m_deleteNodeHotkeyTextCtrl->GetValue().ToStdString();
    btViewSettings.panUpHotkey = m_panUpHotkeyTextCtrl->GetValue().ToStdString();
    btViewSettings.panDownHotkey = m_panDownHotkeyTextCtrl->GetValue().ToStdString();
    btViewSettings.panLeftHotkey = m_panLeftHotkeyTextCtrl->GetValue().ToStdString();
    btViewSettings.panRightHotkey = m_panRightHotkeyTextCtrl->GetValue().ToStdString();
 
    // Debug text settings - Coordinate System Info
    if (m_showCoordinateInfo)
        btViewSettings.showCoordinateInfo = m_showCoordinateInfo->GetValue();
    if (m_coordinateInfoFontSize)
        btViewSettings.coordinateInfoFontSize = m_coordinateInfoFontSize->GetValue();
    if (m_coordinateInfoColorPicker) {
        wxColour coordColor = m_coordinateInfoColorPicker->GetColour();
        btViewSettings.coordinateInfoColor = EmberCore::Color(coordColor.Red(), coordColor.Green(), coordColor.Blue());
    }
    if (m_coordinateInfoAnchor)
        btViewSettings.coordinateInfoAnchor =
            static_cast<EmberForge::AppPreferences::TextAnchor>(m_coordinateInfoAnchor->GetSelection());
    if (m_coordinateInfoX)
        btViewSettings.coordinateInfoX = m_coordinateInfoX->GetValue();
    if (m_coordinateInfoY)
        btViewSettings.coordinateInfoY = m_coordinateInfoY->GetValue();
 
    // Debug text settings - Selected Node Info
    if (m_showSelectedNodeInfo)
        btViewSettings.showSelectedNodeInfo = m_showSelectedNodeInfo->GetValue();
    if (m_selectedNodeInfoFontSize)
        btViewSettings.selectedNodeInfoFontSize = m_selectedNodeInfoFontSize->GetValue();
    if (m_selectedNodeDebugInfoColorPicker) {
        wxColour selColor = m_selectedNodeDebugInfoColorPicker->GetColour();
        btViewSettings.selectedNodeInfoColor = EmberCore::Color(selColor.Red(), selColor.Green(), selColor.Blue());
    }
    if (m_selectedNodeInfoAnchor)
        btViewSettings.selectedNodeInfoAnchor =
            static_cast<EmberForge::AppPreferences::TextAnchor>(m_selectedNodeInfoAnchor->GetSelection());
    if (m_selectedNodeInfoX)
        btViewSettings.selectedNodeInfoX = m_selectedNodeInfoX->GetValue();
    if (m_selectedNodeInfoY)
        btViewSettings.selectedNodeInfoY = m_selectedNodeInfoY->GetValue();
 
    // Debug text settings - Tree Statistics Info
    if (m_showTreeInfo)
        btViewSettings.showTreeInfo = m_showTreeInfo->GetValue();
    if (m_treeInfoFontSize)
        btViewSettings.treeInfoFontSize = m_treeInfoFontSize->GetValue();
    if (m_treeInfoColorPicker) {
        wxColour treeColor = m_treeInfoColorPicker->GetColour();
        btViewSettings.treeInfoColor = EmberCore::Color(treeColor.Red(), treeColor.Green(), treeColor.Blue());
    }
    if (m_treeInfoAnchor)
        btViewSettings.treeInfoAnchor =
            static_cast<EmberForge::AppPreferences::TextAnchor>(m_treeInfoAnchor->GetSelection());
    if (m_treeInfoX)
        btViewSettings.treeInfoX = m_treeInfoX->GetValue();
    if (m_treeInfoY)
        btViewSettings.treeInfoY = m_treeInfoY->GetValue();
 
    // Debug text settings - FPS Display
    if (m_showFPS)
        btViewSettings.showFPS = m_showFPS->GetValue();
    if (m_fpsFontSize)
        btViewSettings.fpsFontSize = m_fpsFontSize->GetValue();
    if (m_fpsColorPicker) {
        wxColour fpsColor = m_fpsColorPicker->GetColour();
        btViewSettings.fpsColor = EmberCore::Color(fpsColor.Red(), fpsColor.Green(), fpsColor.Blue());
    }
    if (m_fpsAnchor)
        btViewSettings.fpsAnchor = static_cast<EmberForge::AppPreferences::TextAnchor>(m_fpsAnchor->GetSelection());
    if (m_fpsX)
        btViewSettings.fpsX = m_fpsX->GetValue();
    if (m_fpsY)
        btViewSettings.fpsY = m_fpsY->GetValue();
 
    // Debug text settings - Controls Help Text
    if (m_showControlsHelp)
        btViewSettings.showControlsHelp = m_showControlsHelp->GetValue();
    if (m_controlsHelpFontSize)
        btViewSettings.controlsHelpFontSize = m_controlsHelpFontSize->GetValue();
    if (m_controlsHelpColorPicker) {
        wxColour ctrlColor = m_controlsHelpColorPicker->GetColour();
        btViewSettings.controlsHelpColor = EmberCore::Color(ctrlColor.Red(), ctrlColor.Green(), ctrlColor.Blue());
    }
    if (m_controlsHelpAnchor)
        btViewSettings.controlsHelpAnchor =
            static_cast<EmberForge::AppPreferences::TextAnchor>(m_controlsHelpAnchor->GetSelection());
    if (m_controlsHelpX)
        btViewSettings.controlsHelpX = m_controlsHelpX->GetValue();
    if (m_controlsHelpY)
        btViewSettings.controlsHelpY = m_controlsHelpY->GetValue();
 
    // Bottom panel container settings
    auto &bottomSettings = prefs.GetBottomPanelSettings();
    bottomSettings.defaultPanelHeightPct = m_bottomPanelHeight->GetValue();
    bottomSettings.defaultPanelHeightEnabled = m_bottomPanelHeightEnabled->GetValue();
    bottomSettings.minimumPanelHeightPct = m_bottomPanelMinHeight->GetValue();
    bottomSettings.minimumPanelHeightEnabled = m_bottomPanelMinHeightEnabled->GetValue();
    bottomSettings.panelStartupState =
        static_cast<AppPreferences::PanelStartupState>(m_bottomPanelStartup->GetSelection());
    bottomSettings.showTabCloseButtons = m_showTabCloseButtons->GetValue();
    bottomSettings.rememberLastTab = m_rememberLastTab->GetValue();
    bottomSettings.allowPanelCollapse = m_allowPanelCollapse->GetValue();
 
    // File Explorer tab general settings
    bottomSettings.showBreadcrumb = m_showBreadcrumb->GetValue();
    bottomSettings.showHistory = m_showHistory->GetValue();
 
    // Start Path Mode
    bottomSettings.startPathMode = static_cast<AppPreferences::StartPathMode>(m_startPathMode->GetSelection());
    bottomSettings.customStartPath = m_customStartPath->GetValue().ToStdString();
 
    // Tree View settings
    bottomSettings.treeView.showHiddenFiles = m_treeShowHiddenFiles->GetValue();
    bottomSettings.treeView.showFileExtensions = m_treeShowFileExtensions->GetValue();
    bottomSettings.treeView.sortFilesBy = static_cast<AppPreferences::SortBy>(m_treeSortFilesBy->GetSelection());
 
    // Tree Item Size
    int treeItemSizeSelection = m_treeItemSize->GetSelection();
    switch (treeItemSizeSelection) {
    case 0:
        bottomSettings.treeView.itemSize = AppPreferences::TreeItemSize::Small;
        break;
    case 1:
        bottomSettings.treeView.itemSize = AppPreferences::TreeItemSize::Medium;
        break;
    case 2:
        bottomSettings.treeView.itemSize = AppPreferences::TreeItemSize::Large;
        break;
    default:
        bottomSettings.treeView.itemSize = AppPreferences::TreeItemSize::Small;
        break;
    }
 
    // Grid View settings
    bottomSettings.gridView.showHiddenFiles = m_gridShowHiddenFiles->GetValue();
    bottomSettings.gridView.showFileExtensions = m_gridShowFileExtensions->GetValue();
    bottomSettings.gridView.sortFilesBy = static_cast<AppPreferences::SortBy>(m_gridSortFilesBy->GetSelection());
 
    // Icon Size
    int iconSizeSelection = m_gridIconSize->GetSelection();
    switch (iconSizeSelection) {
    case 0:
        bottomSettings.gridView.iconSize = AppPreferences::IconSize::Small;
        break;
    case 1:
        bottomSettings.gridView.iconSize = AppPreferences::IconSize::Medium;
        break;
    case 2:
        bottomSettings.gridView.iconSize = AppPreferences::IconSize::Large;
        break;
    default:
        bottomSettings.gridView.iconSize = AppPreferences::IconSize::Medium;
        break;
    }
 
    // Log Tab settings
    bottomSettings.logTab.defaultLevelFilter = m_logDefaultLevelFilter->GetSelection();
    bottomSettings.logTab.autoScrollEnabled = m_logAutoScrollEnabled->GetValue();
    bottomSettings.logTab.maxLogEntries = m_logMaxEntries->GetValue();
    bottomSettings.logTab.enableGuiColors = m_logEnableGuiColors->GetValue();
    bottomSettings.logTab.enableConsoleColors = m_logEnableConsoleColors->GetValue();
 
    int logFontSizeSelection = m_logFontSize->GetSelection();
    switch (logFontSizeSelection) {
    case 0:
        bottomSettings.logTab.fontSize = AppPreferences::LogFontSize::Small;
        break;
    case 1:
        bottomSettings.logTab.fontSize = AppPreferences::LogFontSize::Medium;
        break;
    case 2:
        bottomSettings.logTab.fontSize = AppPreferences::LogFontSize::Large;
        break;
    default:
        bottomSettings.logTab.fontSize = AppPreferences::LogFontSize::Medium;
        break;
    }
 
    // Log level colors
    wxColour traceCol = m_logTraceColor->GetColour();
    bottomSettings.logTab.traceColor = {traceCol.Red(), traceCol.Green(), traceCol.Blue()};
    wxColour infoCol = m_logInfoColor->GetColour();
    bottomSettings.logTab.infoColor = {infoCol.Red(), infoCol.Green(), infoCol.Blue()};
    wxColour warningCol = m_logWarningColor->GetColour();
    bottomSettings.logTab.warningColor = {warningCol.Red(), warningCol.Green(), warningCol.Blue()};
    wxColour errorCol = m_logErrorColor->GetColour();
    bottomSettings.logTab.errorColor = {errorCol.Red(), errorCol.Green(), errorCol.Blue()};
    wxColour criticalCol = m_logCriticalColor->GetColour();
    bottomSettings.logTab.criticalColor = {criticalCol.Red(), criticalCol.Green(), criticalCol.Blue()};
 
    // Left Panel Settings
    auto &leftSettings = prefs.GetLeftPanelSettings();
    leftSettings.defaultPanelWidthEnabled = m_leftPanelWidthEnabled->GetValue();
    leftSettings.defaultPanelWidthPct = m_leftPanelWidth->GetValue();
    leftSettings.minimumPanelWidthEnabled = m_leftPanelMinWidthEnabled->GetValue();
    leftSettings.minimumPanelWidthPct = m_leftPanelMinWidth->GetValue();
 
    int leftPanelStartupSelection = m_leftPanelStartup->GetSelection();
    AppPreferences::PanelStartupState leftStartupState = AppPreferences::PanelStartupState::Show;
    switch (leftPanelStartupSelection) {
    case 0:
        leftStartupState = AppPreferences::PanelStartupState::Show;
        break;
    case 1:
        leftStartupState = AppPreferences::PanelStartupState::Hide;
        break;
    case 2:
        leftStartupState = AppPreferences::PanelStartupState::RememberLast;
        break;
    default:
        leftStartupState = AppPreferences::PanelStartupState::Show;
        break;
    }
    leftSettings.panelStartupState = leftStartupState;
 
    leftSettings.showTabCloseButtons = m_leftPanelShowTabCloseButtons->GetValue();
    leftSettings.rememberLastTab = m_leftPanelRememberLastTab->GetValue();
    leftSettings.allowPanelCollapse = m_leftPanelAllowCollapse->GetValue();
 
    // Right Panel Settings
    auto &rightSettings = prefs.GetRightPanelSettings();
    rightSettings.defaultPanelWidthEnabled = m_rightPanelWidthEnabled->GetValue();
    rightSettings.defaultPanelWidthPct = m_rightPanelWidth->GetValue();
    rightSettings.minimumPanelWidthEnabled = m_rightPanelMinWidthEnabled->GetValue();
    rightSettings.minimumPanelWidthPct = m_rightPanelMinWidth->GetValue();
 
    int rightPanelStartupSelection = m_rightPanelStartup->GetSelection();
    AppPreferences::PanelStartupState rightStartupState = AppPreferences::PanelStartupState::Show;
    switch (rightPanelStartupSelection) {
    case 0:
        rightStartupState = AppPreferences::PanelStartupState::Show;
        break;
    case 1:
        rightStartupState = AppPreferences::PanelStartupState::Hide;
        break;
    case 2:
        rightStartupState = AppPreferences::PanelStartupState::RememberLast;
        break;
    default:
        rightStartupState = AppPreferences::PanelStartupState::Show;
        break;
    }
    rightSettings.panelStartupState = rightStartupState;
 
    rightSettings.showTabCloseButtons = m_rightPanelShowTabCloseButtons->GetValue();
    rightSettings.rememberLastTab = m_rightPanelRememberLastTab->GetValue();
    rightSettings.allowPanelCollapse = m_rightPanelAllowCollapse->GetValue();
 
    // Parser settings
    prefs.GetParserSettings().autoLoadLastFile = m_autoLoadLastFile->GetValue();
    prefs.GetParserSettings().showParseWarnings = m_showParseWarnings->GetValue();
    prefs.GetParserSettings().defaultFileEncoding = m_fileEncoding->GetStringSelection().ToStdString();
 
    // Performance settings
    prefs.GetPerformanceSettings().enableVSync = m_enableVSync->GetValue();
    prefs.GetPerformanceSettings().hardwareAcceleration = m_hardwareAcceleration->GetValue();
    prefs.GetPerformanceSettings().enableDoubleBuffering = m_enableDoubleBuffering->GetValue();
    prefs.GetPerformanceSettings().enableAntiAliasing = m_enableAntiAliasing->GetValue();
    prefs.GetPerformanceSettings().enableTextAntiAliasing = m_enableTextAntiAliasing->GetValue();
    prefs.GetPerformanceSettings().enablePartialRedraws = m_enablePartialRedraws->GetValue();
    prefs.GetPerformanceSettings().enableBackgroundErase = m_enableBackgroundErase->GetValue();
    prefs.GetPerformanceSettings().enableViewportCulling = m_enableViewportCulling->GetValue();
    prefs.GetPerformanceSettings().viewportCullingMargin = m_viewportCullingMargin->GetValue();
    prefs.GetPerformanceSettings().fpsLimit = static_cast<AppPreferences::FPSLimit>(m_fpsLimit->GetSelection());
    prefs.GetPerformanceSettings().enableIdleProcessing = m_enableIdleProcessing->GetValue();
 
    // Save to file
    EmberCore::String configPath = AppPreferences::GetDefaultConfigPath();
    if (prefs.SaveToFile(configPath)) {
        LOG_INFO("Preferences", "Settings saved successfully");
    } else {
        LOG_ERROR("Preferences", "Failed to save settings");
        wxMessageBox("Failed to save preferences to file.", "Error", wxOK | wxICON_ERROR, this);
    }
}
 
void PreferencesDialog::RestoreDefaults() {
    using namespace EmberForge;
    AppPreferences defaultPrefs;
 
    // Load defaults into controls
    auto &winSettings = defaultPrefs.GetWindowSettings();
    m_themeChoice->SetSelection(static_cast<int>(winSettings.theme));
    wxColour accentColor(winSettings.accentColor.r, winSettings.accentColor.g, winSettings.accentColor.b);
    m_accentColorPicker->SetColour(accentColor);
    m_startupModeChoice->SetSelection(static_cast<int>(winSettings.startupMode));
 
    // File menu hotkeys defaults
    m_newProjectHotkeyTextCtrl->SetValue(wxString(winSettings.newProjectHotkey));
    m_openProjectHotkeyTextCtrl->SetValue(wxString(winSettings.openProjectHotkey));
    m_openFileHotkeyTextCtrl->SetValue(wxString(winSettings.openFileHotkey));
    m_saveHotkeyTextCtrl->SetValue(wxString(winSettings.saveHotkey));
    m_saveAsHotkeyTextCtrl->SetValue(wxString(winSettings.saveAsHotkey));
 
    // View menu hotkeys defaults
    m_maximizeHotkeyTextCtrl->SetValue(wxString(winSettings.maximizeHotkey));
    m_resetUIHotkeyTextCtrl->SetValue(wxString(winSettings.resetUIHotkey));
 
    // Settings menu hotkeys defaults
    m_preferencesHotkeyTextCtrl->SetValue(wxString(winSettings.preferencesHotkey));
    m_parserConfigHotkeyTextCtrl->SetValue(wxString(winSettings.parserConfigHotkey));
 
    // Window appearance defaults
    m_showStatusBar->SetValue(winSettings.showStatusBar);
    m_showPanelCaptions->SetValue(winSettings.showPanelCaptions);
    m_alwaysOnTop->SetValue(winSettings.alwaysOnTop);
 
    // Window constraints defaults (percentage of screen)
    m_minWindowWidth->SetValue(winSettings.minWindowWidthPct);
    m_minWindowHeight->SetValue(winSettings.minWindowHeightPct);
    bool maxUnlimited = (winSettings.maxWindowWidthPct == -1);
    m_maxWindowUnlimited->SetValue(maxUnlimited);
    m_maxWindowWidth->SetValue(winSettings.maxWindowWidthPct);
    m_maxWindowHeight->SetValue(winSettings.maxWindowHeightPct);
    m_maxWindowWidth->Enable(!maxUnlimited);
    m_maxWindowHeight->Enable(!maxUnlimited);
 
    m_enforceAspectRatio->SetValue(winSettings.enforceAspectRatio);
    int width = 16, height = 9;
    float ratio = winSettings.aspectRatio;
    if (std::abs(ratio - 16.0f / 9.0f) < 0.01f) {
        width = 16;
        height = 9;
    } else if (std::abs(ratio - 4.0f / 3.0f) < 0.01f) {
        width = 4;
        height = 3;
    } else if (std::abs(ratio - 21.0f / 9.0f) < 0.01f) {
        width = 21;
        height = 9;
    }
    m_aspectRatioWidth->SetValue(wxString::Format("%d", width));
    m_aspectRatioHeight->SetValue(wxString::Format("%d", height));
 
    auto &mainSettings = defaultPrefs.GetMainPanelSettings();
    int zoomPercent = static_cast<int>(mainSettings.defaultZoomLevel * 100);
    m_defaultZoomSlider->SetValue(zoomPercent);
    m_zoomLabel->SetLabel(wxString::Format("%d%%", zoomPercent));
    m_showGrid->SetValue(mainSettings.showGrid);
    m_gridSize->SetValue(mainSettings.gridSize);
    wxColour gridBg(mainSettings.gridBackgroundColor.r, mainSettings.gridBackgroundColor.g,
                    mainSettings.gridBackgroundColor.b);
    m_gridBackgroundPicker->SetColour(gridBg);
    wxColour gridLineColor(mainSettings.gridLineColor.r, mainSettings.gridLineColor.g, mainSettings.gridLineColor.b);
    m_gridLineColorPicker->SetColour(gridLineColor);
    wxColour canvasBg(mainSettings.canvasBackgroundColor.r, mainSettings.canvasBackgroundColor.g,
                      mainSettings.canvasBackgroundColor.b);
    m_canvasBackgroundPicker->SetColour(canvasBg);
    wxColour connectionLineColor(mainSettings.connectionLineColor.r, mainSettings.connectionLineColor.g,
                                 mainSettings.connectionLineColor.b);
    m_connectionLineColorPicker->SetColour(connectionLineColor);
    m_highlightPathToSelected->SetValue(mainSettings.highlightPathToSelected);
    wxColour pathHighlightColor(mainSettings.pathHighlightColor.r, mainSettings.pathHighlightColor.g,
                                mainSettings.pathHighlightColor.b);
    m_pathHighlightColorPicker->SetColour(pathHighlightColor);
    wxColour idleNodeBg(mainSettings.idleNodeBgColor.r, mainSettings.idleNodeBgColor.g, mainSettings.idleNodeBgColor.b);
    m_idleNodeBgColorPicker->SetColour(idleNodeBg);
    wxColour idleNodeBorder(mainSettings.idleNodeBorderColor.r, mainSettings.idleNodeBorderColor.g,
                            mainSettings.idleNodeBorderColor.b);
    m_idleNodeBorderColorPicker->SetColour(idleNodeBorder);
    wxColour idleNodeText(mainSettings.idleNodeTextColor.r, mainSettings.idleNodeTextColor.g,
                          mainSettings.idleNodeTextColor.b);
    m_idleNodeTextColorPicker->SetColour(idleNodeText);
    int selectedTint = static_cast<int>(mainSettings.selectedNodeBgTint * 100);
    m_selectedNodeBgTint->SetValue(selectedTint);
    m_selectedNodeBgTintLabel->SetLabel(wxString::Format("%d%%", selectedTint));
    int hoveredTint = static_cast<int>(mainSettings.hoveredNodeBgTint * 100);
    m_hoveredNodeBgTint->SetValue(hoveredTint);
    m_hoveredNodeBgTintLabel->SetLabel(wxString::Format("%d%%", hoveredTint));
    wxColour selectedNode(mainSettings.selectedNodeColor.r, mainSettings.selectedNodeColor.g,
                          mainSettings.selectedNodeColor.b);
    m_selectedNodeColorPicker->SetColour(selectedNode);
    wxColour hoveredNode(mainSettings.hoveredNodeColor.r, mainSettings.hoveredNodeColor.g,
                         mainSettings.hoveredNodeColor.b);
    m_hoveredNodeColorPicker->SetColour(hoveredNode);
    wxColour selectedNodeText(mainSettings.selectedNodeTextColor.r, mainSettings.selectedNodeTextColor.g,
                              mainSettings.selectedNodeTextColor.b);
    m_selectedNodeTextColorPicker->SetColour(selectedNodeText);
    wxColour hoveredNodeText(mainSettings.hoveredNodeTextColor.r, mainSettings.hoveredNodeTextColor.g,
                             mainSettings.hoveredNodeTextColor.b);
    m_hoveredNodeTextColorPicker->SetColour(hoveredNodeText);
    wxColour selectedNodeInfo(mainSettings.selectedNodeInfoColor.r, mainSettings.selectedNodeInfoColor.g,
                              mainSettings.selectedNodeInfoColor.b);
    m_selectedNodeInfoColorPicker->SetColour(selectedNodeInfo);
    wxColour hoveredNodeInfo(mainSettings.hoveredNodeInfoColor.r, mainSettings.hoveredNodeInfoColor.g,
                             mainSettings.hoveredNodeInfoColor.b);
    m_hoveredNodeInfoColorPicker->SetColour(hoveredNodeInfo);
 
    // Scene management defaults
    bool scenesUnlimited = (mainSettings.maxScenes == -1);
    m_maxScenesUnlimited->SetValue(scenesUnlimited);
    m_maxScenes->SetValue(mainSettings.maxScenes > 0 ? mainSettings.maxScenes : 10);
    m_maxScenes->Enable(!scenesUnlimited);
 
    m_closeConfirmation->SetSelection(static_cast<int>(mainSettings.closeConfirmation));
 
    m_nextSceneHotkeyTextCtrl->SetValue(wxString(mainSettings.nextSceneHotkey));
    m_previousSceneHotkeyTextCtrl->SetValue(wxString(mainSettings.previousSceneHotkey));
 
    // Behavior tree view defaults
    auto &btViewSettings = defaultPrefs.GetBehaviorTreeViewSettings();
    int zoomStepPercent = static_cast<int>(btViewSettings.zoomStepSize * 100);
    m_zoomStepSize->SetValue(zoomStepPercent);
    m_zoomStepSizeLabel->SetLabel(wxString::Format("%d%%", zoomStepPercent));
    int wheelSensitivity = static_cast<int>(btViewSettings.mouseWheelSensitivity * 100);
    m_mouseWheelSensitivity->SetValue(wheelSensitivity);
    m_mouseWheelSensitivityLabel->SetLabel(wxString::Format("%.1fx", btViewSettings.mouseWheelSensitivity));
    m_zoomFollowsCursor->SetValue(btViewSettings.zoomFollowsCursor);
    m_resetViewHotkeyTextCtrl->SetValue(wxString(btViewSettings.resetViewHotkey));
    int panSensitivity = static_cast<int>(btViewSettings.panSensitivity * 100);
    m_panSensitivity->SetValue(panSensitivity);
    m_panSensitivityLabel->SetLabel(wxString::Format("%.1fx", btViewSettings.panSensitivity));
    m_panKeyTextCtrl->SetValue(wxString(btViewSettings.panKey));
    m_enableSmoothPanning->SetValue(btViewSettings.enableSmoothPanning);
    m_panSmoothness->SetValue(static_cast<int>(btViewSettings.panSmoothness));
    m_panSmoothnessLabel->SetLabel(wxString::Format("%d%%", static_cast<int>(btViewSettings.panSmoothness)));
    m_centerOnNodeHotkeyTextCtrl->SetValue(wxString(btViewSettings.centerOnNodeHotkey));
    m_deleteNodeHotkeyTextCtrl->SetValue(wxString(btViewSettings.deleteNodeHotkey));
    m_panUpHotkeyTextCtrl->SetValue(wxString(btViewSettings.panUpHotkey));
    m_panDownHotkeyTextCtrl->SetValue(wxString(btViewSettings.panDownHotkey));
    m_panLeftHotkeyTextCtrl->SetValue(wxString(btViewSettings.panLeftHotkey));
    m_panRightHotkeyTextCtrl->SetValue(wxString(btViewSettings.panRightHotkey));
 
    auto &bottomSettings = defaultPrefs.GetBottomPanelSettings();
    // Bottom panel container settings
    m_bottomPanelHeight->SetValue(bottomSettings.defaultPanelHeightPct);
    m_bottomPanelHeightEnabled->SetValue(bottomSettings.defaultPanelHeightEnabled);
    m_bottomPanelHeight->Enable(bottomSettings.defaultPanelHeightEnabled);
    m_bottomPanelMinHeight->SetValue(bottomSettings.minimumPanelHeightPct);
    m_bottomPanelMinHeightEnabled->SetValue(bottomSettings.minimumPanelHeightEnabled);
    m_bottomPanelMinHeight->Enable(bottomSettings.minimumPanelHeightEnabled);
    m_bottomPanelStartup->SetSelection(static_cast<int>(bottomSettings.panelStartupState));
    m_showTabCloseButtons->SetValue(bottomSettings.showTabCloseButtons);
    m_rememberLastTab->SetValue(bottomSettings.rememberLastTab);
    m_allowPanelCollapse->SetValue(bottomSettings.allowPanelCollapse);
 
    // File Explorer tab general settings
    m_showBreadcrumb->SetValue(bottomSettings.showBreadcrumb);
    m_showHistory->SetValue(bottomSettings.showHistory);
 
    // Start Path Mode
    int defStartPathModeIndex = static_cast<int>(bottomSettings.startPathMode);
    m_startPathMode->SetSelection(defStartPathModeIndex);
    m_customStartPath->SetValue(wxString(bottomSettings.customStartPath));
    bool defEnableCustomPath = (defStartPathModeIndex == 1); // CustomPath (second option)
    m_customStartPath->Enable(defEnableCustomPath);
    m_browseStartPath->Enable(defEnableCustomPath);
 
    // Tree View settings
    m_treeShowHiddenFiles->SetValue(bottomSettings.treeView.showHiddenFiles);
    m_treeShowFileExtensions->SetValue(bottomSettings.treeView.showFileExtensions);
    m_treeSortFilesBy->SetSelection(static_cast<int>(bottomSettings.treeView.sortFilesBy));
 
    // Tree Item Size
    int defTreeItemSizeIndex = 1; // Default to Medium
    switch (bottomSettings.treeView.itemSize) {
    case AppPreferences::TreeItemSize::Small:
        defTreeItemSizeIndex = 0;
        break;
    case AppPreferences::TreeItemSize::Medium:
        defTreeItemSizeIndex = 1;
        break;
    case AppPreferences::TreeItemSize::Large:
        defTreeItemSizeIndex = 2;
        break;
    }
    m_treeItemSize->SetSelection(defTreeItemSizeIndex);
 
    // Grid View settings
    m_gridShowHiddenFiles->SetValue(bottomSettings.gridView.showHiddenFiles);
    m_gridShowFileExtensions->SetValue(bottomSettings.gridView.showFileExtensions);
    m_gridSortFilesBy->SetSelection(static_cast<int>(bottomSettings.gridView.sortFilesBy));
 
    // Icon Size
    int defIconSizeIndex = 1; // Default to Medium
    switch (bottomSettings.gridView.iconSize) {
    case AppPreferences::IconSize::Small:
        defIconSizeIndex = 0;
        break;
    case AppPreferences::IconSize::Medium:
        defIconSizeIndex = 1;
        break;
    case AppPreferences::IconSize::Large:
        defIconSizeIndex = 2;
        break;
    }
    m_gridIconSize->SetSelection(defIconSizeIndex);
 
    // Log Tab settings
    m_logDefaultLevelFilter->SetSelection(bottomSettings.logTab.defaultLevelFilter);
    m_logAutoScrollEnabled->SetValue(bottomSettings.logTab.autoScrollEnabled);
    m_logMaxEntries->SetValue(bottomSettings.logTab.maxLogEntries);
    m_logEnableGuiColors->SetValue(bottomSettings.logTab.enableGuiColors);
    m_logEnableConsoleColors->SetValue(bottomSettings.logTab.enableConsoleColors);
 
    int defLogFontSizeIndex = 1; // Default to Medium
    switch (bottomSettings.logTab.fontSize) {
    case AppPreferences::LogFontSize::Small:
        defLogFontSizeIndex = 0;
        break;
    case AppPreferences::LogFontSize::Medium:
        defLogFontSizeIndex = 1;
        break;
    case AppPreferences::LogFontSize::Large:
        defLogFontSizeIndex = 2;
        break;
    }
    m_logFontSize->SetSelection(defLogFontSizeIndex);
 
    // Log level colors (defaults)
    m_logTraceColor->SetColour(wxColour(bottomSettings.logTab.traceColor.r, bottomSettings.logTab.traceColor.g,
                                        bottomSettings.logTab.traceColor.b));
    m_logInfoColor->SetColour(wxColour(bottomSettings.logTab.infoColor.r, bottomSettings.logTab.infoColor.g,
                                       bottomSettings.logTab.infoColor.b));
    m_logWarningColor->SetColour(wxColour(bottomSettings.logTab.warningColor.r, bottomSettings.logTab.warningColor.g,
                                          bottomSettings.logTab.warningColor.b));
    m_logErrorColor->SetColour(wxColour(bottomSettings.logTab.errorColor.r, bottomSettings.logTab.errorColor.g,
                                        bottomSettings.logTab.errorColor.b));
    m_logCriticalColor->SetColour(wxColour(bottomSettings.logTab.criticalColor.r, bottomSettings.logTab.criticalColor.g,
                                           bottomSettings.logTab.criticalColor.b));
 
    // Left Panel Settings (defaults)
    const auto &defLeftSettings = defaultPrefs.GetLeftPanelSettings();
    m_leftPanelWidthEnabled->SetValue(defLeftSettings.defaultPanelWidthEnabled);
    m_leftPanelWidth->SetValue(defLeftSettings.defaultPanelWidthPct);
    m_leftPanelWidth->Enable(defLeftSettings.defaultPanelWidthEnabled);
    m_leftPanelMinWidthEnabled->SetValue(defLeftSettings.minimumPanelWidthEnabled);
    m_leftPanelMinWidth->SetValue(defLeftSettings.minimumPanelWidthPct);
    m_leftPanelMinWidth->Enable(defLeftSettings.minimumPanelWidthEnabled);
 
    int defLeftPanelStartupIndex = 0;
    switch (defLeftSettings.panelStartupState) {
    case AppPreferences::PanelStartupState::Show:
        defLeftPanelStartupIndex = 0;
        break;
    case AppPreferences::PanelStartupState::Hide:
        defLeftPanelStartupIndex = 1;
        break;
    case AppPreferences::PanelStartupState::RememberLast:
        defLeftPanelStartupIndex = 2;
        break;
    }
    m_leftPanelStartup->SetSelection(defLeftPanelStartupIndex);
 
    m_leftPanelShowTabCloseButtons->SetValue(defLeftSettings.showTabCloseButtons);
    m_leftPanelRememberLastTab->SetValue(defLeftSettings.rememberLastTab);
    m_leftPanelAllowCollapse->SetValue(defLeftSettings.allowPanelCollapse);
 
    // Right Panel Settings (defaults)
    const auto &defRightSettings = defaultPrefs.GetRightPanelSettings();
    m_rightPanelWidthEnabled->SetValue(defRightSettings.defaultPanelWidthEnabled);
    m_rightPanelWidth->SetValue(defRightSettings.defaultPanelWidthPct);
    m_rightPanelWidth->Enable(defRightSettings.defaultPanelWidthEnabled);
    m_rightPanelMinWidthEnabled->SetValue(defRightSettings.minimumPanelWidthEnabled);
    m_rightPanelMinWidth->SetValue(defRightSettings.minimumPanelWidthPct);
    m_rightPanelMinWidth->Enable(defRightSettings.minimumPanelWidthEnabled);
 
    int defRightPanelStartupIndex = 0;
    switch (defRightSettings.panelStartupState) {
    case AppPreferences::PanelStartupState::Show:
        defRightPanelStartupIndex = 0;
        break;
    case AppPreferences::PanelStartupState::Hide:
        defRightPanelStartupIndex = 1;
        break;
    case AppPreferences::PanelStartupState::RememberLast:
        defRightPanelStartupIndex = 2;
        break;
    }
    m_rightPanelStartup->SetSelection(defRightPanelStartupIndex);
 
    m_rightPanelShowTabCloseButtons->SetValue(defRightSettings.showTabCloseButtons);
    m_rightPanelRememberLastTab->SetValue(defRightSettings.rememberLastTab);
    m_rightPanelAllowCollapse->SetValue(defRightSettings.allowPanelCollapse);
 
    auto &parserSettings = defaultPrefs.GetParserSettings();
    m_autoLoadLastFile->SetValue(parserSettings.autoLoadLastFile);
    m_showParseWarnings->SetValue(parserSettings.showParseWarnings);
    m_fileEncoding->SetSelection(0); // UTF-8
 
    auto &perfSettings = defaultPrefs.GetPerformanceSettings();
    m_enableVSync->SetValue(perfSettings.enableVSync);
    m_hardwareAcceleration->SetValue(perfSettings.hardwareAcceleration);
    m_enableDoubleBuffering->SetValue(perfSettings.enableDoubleBuffering);
    m_enableAntiAliasing->SetValue(perfSettings.enableAntiAliasing);
    m_enableTextAntiAliasing->SetValue(perfSettings.enableTextAntiAliasing);
    m_enablePartialRedraws->SetValue(perfSettings.enablePartialRedraws);
    m_enableBackgroundErase->SetValue(perfSettings.enableBackgroundErase);
    m_enableViewportCulling->SetValue(perfSettings.enableViewportCulling);
    m_viewportCullingMargin->SetValue(perfSettings.viewportCullingMargin);
    m_fpsLimit->SetSelection(static_cast<int>(perfSettings.fpsLimit));
    m_enableIdleProcessing->SetValue(perfSettings.enableIdleProcessing);
 
    LOG_INFO("Preferences", "Settings restored to defaults (not saved yet)");
}
 
void PreferencesDialog::OnSectionSelected(wxTreeEvent &event) {
    wxTreeItemId itemId = event.GetItem();
    if (!itemId.IsOk())
        return;
 
    SectionTreeItemData *data = dynamic_cast<SectionTreeItemData *>(m_sectionTree->GetItemData(itemId));
    if (data && data->GetPanel()) {
        ShowPanel(data->GetPanel());
    }
}
 
void PreferencesDialog::OnZoomSliderChanged(wxCommandEvent &event) {
    // Update labels depending on which slider triggered the event
    if (event.GetId() == ID_DEFAULT_ZOOM) {
        int zoomPercent = m_defaultZoomSlider->GetValue();
        m_zoomLabel->SetLabel(wxString::Format("%d%%", zoomPercent));
    } else if (event.GetId() == ID_ZOOM_STEP_SIZE) {
        int zoomStepPercent = m_zoomStepSize->GetValue();
        m_zoomStepSizeLabel->SetLabel(wxString::Format("%d%%", zoomStepPercent));
    } else if (event.GetId() == ID_SELECTED_NODE_BG_TINT) {
        int tintPercent = m_selectedNodeBgTint->GetValue();
        m_selectedNodeBgTintLabel->SetLabel(wxString::Format("%d%%", tintPercent));
    } else if (event.GetId() == ID_HOVERED_NODE_BG_TINT) {
        int tintPercent = m_hoveredNodeBgTint->GetValue();
        m_hoveredNodeBgTintLabel->SetLabel(wxString::Format("%d%%", tintPercent));
    }
}
 
void PreferencesDialog::OnMouseWheelSensitivityChanged(wxCommandEvent &event) {
    // Update mouse wheel sensitivity label
    int value = m_mouseWheelSensitivity->GetValue();
    float sensitivity = value / 100.0f;
    m_mouseWheelSensitivityLabel->SetLabel(wxString::Format("%.1fx", sensitivity));
}
 
void PreferencesDialog::OnPanSensitivityChanged(wxCommandEvent &event) {
    // Update pan sensitivity label
    int value = m_panSensitivity->GetValue();
    float sensitivity = value / 100.0f;
    m_panSensitivityLabel->SetLabel(wxString::Format("%.1fx", sensitivity));
}
 
void PreferencesDialog::OnPanSmoothnessChanged(wxCommandEvent &event) {
    // Update pan smoothness label
    int value = m_panSmoothness->GetValue();
    m_panSmoothnessLabel->SetLabel(wxString::Format("%d%%", value));
}
 
void PreferencesDialog::OnPanStepSizeChanged(wxCommandEvent &event) {
    // Update pan step size label
    int value = m_panStepSize->GetValue();
    m_panStepSizeLabel->SetLabel(wxString::Format("%dpx", value));
}
 
void PreferencesDialog::OnSliderMouseWheel(wxMouseEvent &event) {
    // Only allow mouse wheel events if the slider has focus (was clicked on)
    // This prevents sliders from intercepting scroll events meant for the page
    wxWindow *eventWindow = dynamic_cast<wxWindow *>(event.GetEventObject());
    if (eventWindow && eventWindow->HasFocus()) {
        // Allow the slider to handle the mouse wheel event
        event.Skip();
    }
    // If slider doesn't have focus, don't skip - this blocks the event
    // and allows it to propagate to the parent scroll window
}
 
void PreferencesDialog::OnDialogMouseDown(wxMouseEvent &event) {
    // Only process if we're in capture mode (for hotkey capture)
    if (!m_capturingTextCtrl) {
        event.Skip();
        return;
    }
 
    // Only capture if the text shows we're in capture mode
    wxString currentValue = m_capturingTextCtrl->GetValue();
    if (currentValue != "Press a key...") {
        // Capture mode ended
        if (HasCapture()) {
            ReleaseMouse();
        }
        m_capturingTextCtrl = nullptr;
        // Remove focus to stop capturing
        if (m_okButton) {
            m_okButton->SetFocus();
        }
        event.Skip();
        return;
    }
 
    // Determine which mouse button was pressed
    wxString buttonName;
    wxString warningMessage;
 
    if (event.LeftDown()) {
        buttonName = "Left Mouse Button";
        // Check if this is the pan key control
        if (m_capturingTextCtrl == m_panKeyTextCtrl) {
            warningMessage = "Warning: Left Mouse Button is the default for node selection.\n\n"
                             "Setting it as the pan button will disable click-to-select functionality.\n\n"
                             "Are you sure you want to use Left Mouse Button for panning?";
        }
    } else if (event.MiddleDown()) {
        buttonName = "Middle Mouse Button";
    } else if (event.RightDown()) {
        buttonName = "Right Mouse Button";
        // Check if this is the pan key control
        if (m_capturingTextCtrl == m_panKeyTextCtrl) {
            warningMessage = "Warning: Right Mouse Button is reserved for context menus.\n\n"
                             "Setting it as the pan button may interfere with future context menu functionality.\n\n"
                             "Are you sure you want to use Right Mouse Button for panning?";
        }
    }
 
    if (!buttonName.IsEmpty()) {
        // Release mouse capture before showing message box
        // (modal dialogs don't work well with active mouse capture)
        if (HasCapture()) {
            ReleaseMouse();
        }
 
        // Show warning if applicable
        if (!warningMessage.IsEmpty()) {
            int response = wxMessageBox(warningMessage, "Panning Button Warning", wxYES_NO | wxICON_WARNING, this);
            if (response != wxYES) {
                // User declined, reset capture state and clear the field
                m_capturingTextCtrl->SetValue("");
                m_capturingTextCtrl = nullptr;
                // Remove focus to stop capturing
                if (m_okButton) {
                    m_okButton->SetFocus();
                }
                return;
            }
        }
 
        // Set the value and clear capture state
        m_capturingTextCtrl->SetValue(buttonName);
        m_capturingTextCtrl = nullptr;
 
        // Remove focus to stop capturing
        if (m_okButton) {
            m_okButton->SetFocus();
        }
    }
 
    // Don't skip the event to prevent it from propagating further
}
 
void PreferencesDialog::OnMaxWindowUnlimitedChanged(wxCommandEvent &event) {
    // Enable/disable max window size controls based on checkbox
    bool unlimited = m_maxWindowUnlimited->GetValue();
    m_maxWindowWidth->Enable(!unlimited);
    m_maxWindowHeight->Enable(!unlimited);
}
 
void PreferencesDialog::OnMaxScenesUnlimitedChanged(wxCommandEvent &event) {
    // Enable/disable max scenes control based on checkbox
    bool unlimited = m_maxScenesUnlimited->GetValue();
    m_maxScenes->Enable(!unlimited);
}
 
void PreferencesDialog::OnBottomPanelHeightEnabledChanged(wxCommandEvent &event) {
    // Enable/disable default panel height control based on checkbox
    bool enabled = m_bottomPanelHeightEnabled->GetValue();
    m_bottomPanelHeight->Enable(enabled);
}
 
void PreferencesDialog::OnBottomPanelMinHeightEnabledChanged(wxCommandEvent &event) {
    // Enable/disable minimum panel height control based on checkbox
    bool enabled = m_bottomPanelMinHeightEnabled->GetValue();
    m_bottomPanelMinHeight->Enable(enabled);
}
 
void PreferencesDialog::OnLeftPanelWidthEnabledChanged(wxCommandEvent &event) {
    // Enable/disable default panel width control based on checkbox
    bool enabled = m_leftPanelWidthEnabled->GetValue();
    m_leftPanelWidth->Enable(enabled);
}
 
void PreferencesDialog::OnLeftPanelMinWidthEnabledChanged(wxCommandEvent &event) {
    // Enable/disable minimum panel width control based on checkbox
    bool enabled = m_leftPanelMinWidthEnabled->GetValue();
    m_leftPanelMinWidth->Enable(enabled);
}
 
void PreferencesDialog::OnRightPanelWidthEnabledChanged(wxCommandEvent &event) {
    // Enable/disable default panel width control based on checkbox
    bool enabled = m_rightPanelWidthEnabled->GetValue();
    m_rightPanelWidth->Enable(enabled);
}
 
void PreferencesDialog::OnRightPanelMinWidthEnabledChanged(wxCommandEvent &event) {
    // Enable/disable minimum panel width control based on checkbox
    bool enabled = m_rightPanelMinWidthEnabled->GetValue();
    m_rightPanelMinWidth->Enable(enabled);
}
 
void PreferencesDialog::OnHotkeyCaptureClicked(wxCommandEvent &event) {
    wxButton *button = dynamic_cast<wxButton *>(event.GetEventObject());
    if (!button)
        return;
 
    // Determine which hotkey is being captured
    wxTextCtrl *textCtrl = nullptr;
    // File menu hotkeys
    if (button == m_newProjectHotkeyCaptureButton) {
        textCtrl = m_newProjectHotkeyTextCtrl;
    } else if (button == m_openProjectHotkeyCaptureButton) {
        textCtrl = m_openProjectHotkeyTextCtrl;
    } else if (button == m_openFileHotkeyCaptureButton) {
        textCtrl = m_openFileHotkeyTextCtrl;
    } else if (button == m_saveHotkeyCaptureButton) {
        textCtrl = m_saveHotkeyTextCtrl;
    } else if (button == m_saveAsHotkeyCaptureButton) {
        textCtrl = m_saveAsHotkeyTextCtrl;
        // View menu hotkeys
    } else if (button == m_maximizeHotkeyCaptureButton) {
        textCtrl = m_maximizeHotkeyTextCtrl;
    } else if (button == m_resetUIHotkeyCaptureButton) {
        textCtrl = m_resetUIHotkeyTextCtrl;
        // Settings menu hotkeys
    } else if (button == m_preferencesHotkeyCaptureButton) {
        textCtrl = m_preferencesHotkeyTextCtrl;
    } else if (button == m_parserConfigHotkeyCaptureButton) {
        textCtrl = m_parserConfigHotkeyTextCtrl;
        // Main panel hotkeys
    } else if (button == m_nextSceneHotkeyCaptureButton) {
        textCtrl = m_nextSceneHotkeyTextCtrl;
    } else if (button == m_previousSceneHotkeyCaptureButton) {
        textCtrl = m_previousSceneHotkeyTextCtrl;
    } else if (button == m_resetViewHotkeyCaptureButton) {
        textCtrl = m_resetViewHotkeyTextCtrl;
    } else if (button == m_panKeyCaptureButton) {
        textCtrl = m_panKeyTextCtrl;
    } else if (button == m_centerOnNodeHotkeyCaptureButton) {
        textCtrl = m_centerOnNodeHotkeyTextCtrl;
    } else if (button == m_deleteNodeHotkeyCaptureButton) {
        textCtrl = m_deleteNodeHotkeyTextCtrl;
    } else if (button == m_panUpHotkeyCaptureButton) {
        textCtrl = m_panUpHotkeyTextCtrl;
    } else if (button == m_panDownHotkeyCaptureButton) {
        textCtrl = m_panDownHotkeyTextCtrl;
    } else if (button == m_panLeftHotkeyCaptureButton) {
        textCtrl = m_panLeftHotkeyTextCtrl;
    } else if (button == m_panRightHotkeyCaptureButton) {
        textCtrl = m_panRightHotkeyTextCtrl;
    }
 
    if (textCtrl) {
        textCtrl->SetValue("Press a key...");
        textCtrl->SetFocus();
 
        // Set the capturing control and capture mouse at dialog level
        m_capturingTextCtrl = textCtrl;
        if (!HasCapture()) {
            CaptureMouse();
        }
    }
}
 
void PreferencesDialog::OnHotkeyTextKeyDown(wxKeyEvent &event) {
    wxTextCtrl *textCtrl = dynamic_cast<wxTextCtrl *>(event.GetEventObject());
    if (!textCtrl) {
        event.Skip();
        return;
    }
 
    // Only process if this is the text control we're capturing for
    // (prevents issues if focus somehow moves to a different control)
    if (m_capturingTextCtrl && m_capturingTextCtrl != textCtrl) {
        event.Skip();
        return;
    }
 
    int keyCode = event.GetKeyCode();
 
    // Handle Escape key specially - cancel capture mode without changing value
    if (keyCode == WXK_ESCAPE && textCtrl->GetValue() == "Press a key...") {
        textCtrl->SetValue(""); // Clear the field
        if (HasCapture()) {
            ReleaseMouse();
        }
        m_capturingTextCtrl = nullptr;
        // Remove focus to stop capturing
        if (m_okButton) {
            m_okButton->SetFocus();
        }
        return;
    }
 
    wxString hotkeyStr;
 
    // Build modifier string
    if (event.ControlDown())
        hotkeyStr += "Ctrl+";
    if (event.AltDown())
        hotkeyStr += "Alt+";
    if (event.ShiftDown())
        hotkeyStr += "Shift+";
 
    // Add key name
    if (keyCode >= WXK_F1 && keyCode <= WXK_F12) {
        hotkeyStr += wxString::Format("F%d", keyCode - WXK_F1 + 1);
    } else if (keyCode >= 'A' && keyCode <= 'Z') {
        hotkeyStr += wxChar(keyCode);
    } else if (keyCode >= '0' && keyCode <= '9') {
        hotkeyStr += wxChar(keyCode);
    } else {
        // Map special keys
        switch (keyCode) {
        case WXK_ESCAPE:
            hotkeyStr += "Esc";
            break;
        case WXK_SPACE:
            hotkeyStr += "Space";
            break;
        case WXK_RETURN:
            hotkeyStr += "Enter";
            break;
        case WXK_TAB:
            hotkeyStr += "Tab";
            break;
        case WXK_BACK:
            hotkeyStr += "Backspace";
            break;
        case WXK_DELETE:
            hotkeyStr += "Delete";
            break;
        case WXK_INSERT:
            hotkeyStr += "Insert";
            break;
        case WXK_HOME:
            hotkeyStr += "Home";
            break;
        case WXK_END:
            hotkeyStr += "End";
            break;
        case WXK_PAGEUP:
            hotkeyStr += "PageUp";
            break;
        case WXK_PAGEDOWN:
            hotkeyStr += "PageDown";
            break;
        case WXK_LEFT:
            hotkeyStr += "Left";
            break;
        case WXK_RIGHT:
            hotkeyStr += "Right";
            break;
        case WXK_UP:
            hotkeyStr += "Up";
            break;
        case WXK_DOWN:
            hotkeyStr += "Down";
            break;
        default:
            textCtrl->SetValue("Unsupported key");
            if (HasCapture()) {
                ReleaseMouse();
            }
            m_capturingTextCtrl = nullptr;
            // Remove focus to stop capturing
            if (m_okButton) {
                m_okButton->SetFocus();
            }
            return;
        }
    }
 
    textCtrl->SetValue(hotkeyStr);
 
    // Release the mouse capture after successfully capturing a key
    if (HasCapture()) {
        ReleaseMouse();
    }
    m_capturingTextCtrl = nullptr;
 
    // Remove focus from the text control to stop capturing further keys
    // Transfer focus to the OK button (or any other safe control)
    if (m_okButton) {
        m_okButton->SetFocus();
    }
}
 
void PreferencesDialog::OnOK(wxCommandEvent &event) {
    // Release mouse capture if active
    if (HasCapture()) {
        ReleaseMouse();
    }
    m_capturingTextCtrl = nullptr;
 
    ApplySettings();
    EndModal(wxID_OK);
}
 
void PreferencesDialog::OnCancel(wxCommandEvent &event) {
    // Release mouse capture if active
    if (HasCapture()) {
        ReleaseMouse();
    }
    m_capturingTextCtrl = nullptr;
 
    EndModal(wxID_CANCEL);
}
 
void PreferencesDialog::OnApply(wxCommandEvent &event) {
    ApplySettings();
 
    // Notify parent frame to refresh UI with new settings
    MainFrame *mainFrame = dynamic_cast<MainFrame *>(GetParent());
    if (mainFrame) {
        mainFrame->RefreshPreferences();
    }
}
 
void PreferencesDialog::OnRestoreDefaults(wxCommandEvent &event) {
    int result = wxMessageBox("This will restore all settings to their default values. Continue?", "Restore Defaults",
                              wxYES_NO | wxICON_QUESTION, this);
    if (result == wxYES) {
        RestoreDefaults();
    }
}
 
void PreferencesDialog::OnConfigureParser(wxCommandEvent &event) {
    ParserConfigDialog dialog(this);
    dialog.ShowModal();
}
 
void PreferencesDialog::OnStartPathModeChanged(wxCommandEvent &event) {
    // Enable/disable custom path controls based on selection
    if (m_startPathMode && m_customStartPath && m_browseStartPath) {
        int selection = m_startPathMode->GetSelection();
        bool enableCustomPath = (selection == 1); // "Custom Path" is the second option
        m_customStartPath->Enable(enableCustomPath);
        m_browseStartPath->Enable(enableCustomPath);
    }
}
 
void PreferencesDialog::OnBrowseStartPath(wxCommandEvent &event) {
    wxDirDialog dialog(this, "Choose Start Directory", m_customStartPath->GetValue(),
                       wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
 
    if (dialog.ShowModal() == wxID_OK) {
        m_customStartPath->SetValue(dialog.GetPath());
    }
}