AppPreferences.h

Go to the documentation of this file.

#pragma once

 
#include "Types/Color.h"
#include "Types/String.h"
#include <string>
#include <vector>
 
// Forward declarations
class wxColour;
 
namespace EmberForge {

class AppPreferences {
  public:
    enum class ThemeMode { Dark, Light };

    enum class StartupMode { Normal, Maximized };

    enum class SortBy { Name, Date, Size, Type };

    enum class IconSize {
        Small = 48,  // 48x48
        Medium = 80, // 80x80
        Large = 128  // 128x128
    };

    enum class TreeItemSize {
        Small = 16,  // 16x16 icons, compact rows
        Medium = 24, // 24x24 icons, standard rows
        Large = 32   // 32x32 icons, spacious rows
    };

    enum class StartPathMode {
        ExecutableDirectory, // Always start at executable directory
        CustomPath           // Use custom path
    };

    enum class FPSLimit { FPS_30, FPS_60, FPS_120, Unlimited };

    enum class CloseConfirmationMode { AlwaysAsk, NeverAsk, AskIfUnsaved };

    struct WindowSettings {
        int windowX = -1;                              // Window X position (-1 = center)
        int windowY = -1;                              // Window Y position (-1 = center)
        int windowWidth = 1280;                        // Window width
        int windowHeight = 720;                        // Window height
        StartupMode startupMode = StartupMode::Normal; // Startup mode (normal/maximized)
        EmberCore::String maximizeHotkey = "F11";      // Hotkey for maximize toggle
 
        // File menu hotkeys
        EmberCore::String newProjectHotkey = "Ctrl+Shift+N";  // Hotkey for new project
        EmberCore::String openProjectHotkey = "Ctrl+Shift+O"; // Hotkey for open project
        EmberCore::String openFileHotkey = "Ctrl+O";          // Hotkey for open XML file
        EmberCore::String saveHotkey = "Ctrl+S";              // Hotkey for save
        EmberCore::String saveAsHotkey = "Ctrl+Shift+S";      // Hotkey for save as
 
        // View menu hotkeys
        EmberCore::String resetUIHotkey = "Ctrl+Shift+R"; // Hotkey for reset UI
 
        // Settings menu hotkeys
        EmberCore::String preferencesHotkey = "Ctrl+,";        // Hotkey for preferences
        EmberCore::String parserConfigHotkey = "Ctrl+Shift+P"; // Hotkey for parser config
 
        ThemeMode theme = ThemeMode::Dark;                              // Theme mode
        EmberCore::Color accentColor = EmberCore::Color(100, 149, 237); // Cornflower blue
 
        // Window appearance and behavior
        bool showStatusBar = true;      // Show status bar at bottom
        bool showPanelCaptions = false; // Show caption headers on panels
        bool alwaysOnTop = false;       // Keep window above all others (wxSTAY_ON_TOP)
 
        // Window constraints (percentage of screen)
        int minWindowWidthPct = 42;       // Minimum window width (% of screen)
        int minWindowHeightPct = 56;      // Minimum window height (% of screen)
        int maxWindowWidthPct = -1;       // Maximum window width (% of screen, -1=unlimited)
        int maxWindowHeightPct = -1;      // Maximum window height (% of screen, -1=unlimited)
        bool enforceAspectRatio = false;  // Enforce aspect ratio (16:9)
        float aspectRatio = 16.0f / 9.0f; // Aspect ratio to enforce
    };

    struct MainPanelSettings {
        float defaultZoomLevel = 1.0f;                                          // Default zoom (0.1-2.0)
        bool showGrid = true;                                                   // Show grid on canvas
        int gridSize = 20;                                                      // Grid size in pixels (10-100)
        EmberCore::Color gridBackgroundColor = EmberCore::Color(45, 45, 45);    // Grid background color
        EmberCore::Color gridLineColor = EmberCore::Color(54, 54, 54);          // Grid line color
        bool snapToGrid = false;                                                // Snap nodes to grid
        EmberCore::Color canvasBackgroundColor = EmberCore::Color(50, 50, 50);  // Canvas background
        EmberCore::Color connectionLineColor = EmberCore::Color(255, 255, 255); // Connection line color (white)
        bool highlightPathToSelected = true; // Highlight path from root to selected node
        EmberCore::Color pathHighlightColor = EmberCore::Color(144, 238, 144);  // Path highlight color (light green)
        EmberCore::Color idleNodeBgColor = EmberCore::Color(75, 75, 75);        // Idle node background color
        EmberCore::Color idleNodeBorderColor = EmberCore::Color(120, 120, 120); // Idle node border color (gray)
        EmberCore::Color idleNodeTextColor = EmberCore::Color(180, 180, 180);   // Idle node text color (light gray)
        float selectedNodeBgTint = -0.33f; // Selected node background tint (-1.0 to 1.0, negative = darker)
        float hoveredNodeBgTint = -0.13f;  // Hovered node background tint (-1.0 to 1.0, negative = darker)
        EmberCore::Color selectedNodeColor = EmberCore::Color(48, 92, 222);  // Selected node border color (blue)
        EmberCore::Color hoveredNodeColor = EmberCore::Color(144, 238, 144); // Hovered node border color (light green)
        EmberCore::Color selectedNodeTextColor = EmberCore::Color(255, 255, 255); // Selected node text color (white)
        EmberCore::Color hoveredNodeTextColor = EmberCore::Color(255, 255, 255);  // Hovered node text color (white)
        EmberCore::Color selectedNodeInfoColor =
            EmberCore::Color(200, 200, 200); // Selected node info text color (light gray)
        EmberCore::Color hoveredNodeInfoColor =
            EmberCore::Color(200, 200, 200); // Hovered node info text color (light gray)
        int maxScenes = 10;                  // Maximum number of scenes/tabs (1-50, -1=unlimited)
        CloseConfirmationMode closeConfirmation = CloseConfirmationMode::AskIfUnsaved; // Scene close confirmation
        EmberCore::String nextSceneHotkey = "Ctrl+Tab";                                // Hotkey to switch to next scene
        EmberCore::String previousSceneHotkey = "Ctrl+Shift+Tab"; // Hotkey to switch to previous scene
        bool showMinimap = true;
        bool showCanvasBreadcrumb = true;
    };

    enum class TextAnchor { TopLeft = 0, TopRight = 1, BottomLeft = 2, BottomRight = 3 };

    struct BehaviorTreeViewSettings {
        // Zoom settings
        float zoomStepSize = 0.1f;               // Zoom step size (0.05-0.5, represents 5%-50%)
        float mouseWheelSensitivity = 1.0f;      // Mouse wheel zoom sensitivity multiplier (0.1-5.0)
        bool zoomFollowsCursor = true;           // Zoom towards cursor position vs center
        EmberCore::String resetViewHotkey = "R"; // Hotkey to reset view (zoom + pan)
 
        // Pan settings
        float panSensitivity = 1.51f;                     // Pan sensitivity multiplier (0.1-2.0)
        EmberCore::String panKey = "Middle Mouse Button"; // Key/button to hold while moving mouse to pan
        bool enableSmoothPanning = false;                 // Enable smooth panning animation
        float panSmoothness = 30.0f;                      // Pan smoothness (0-100, higher = smoother/slower)
        float panStepSize = 40.0f;                        // Arrow key pan step size in pixels (10-500)
 
        // Navigation hotkeys
        EmberCore::String centerOnNodeHotkey = "C";    // Hotkey to center on selected node
        EmberCore::String deleteNodeHotkey = "Delete"; // Hotkey to delete selected node
        EmberCore::String panUpHotkey = "Up";          // Hotkey to pan view up
        EmberCore::String panDownHotkey = "Down";      // Hotkey to pan view down
        EmberCore::String panLeftHotkey = "Left";      // Hotkey to pan view left
        EmberCore::String panRightHotkey = "Right";    // Hotkey to pan view right
 
        // Debug text - Coordinate System Info (zoom and pan)
        bool showCoordinateInfo = true;                                         // Show coordinate system information
        int coordinateInfoFontSize = 9;                                         // Font size for coordinate info (6-20)
        EmberCore::Color coordinateInfoColor = EmberCore::Color(200, 200, 200); // Coordinate info text color
        TextAnchor coordinateInfoAnchor = TextAnchor::TopLeft;                  // Anchor position
        int coordinateInfoX = 10;                                               // X offset from anchor (0-9999)
        int coordinateInfoY = 34;                                               // Y offset from anchor (0-9999)
 
        // Debug text - Selected Node Info
        bool showSelectedNodeInfo = true; // Show selected node information
        int selectedNodeInfoFontSize = 9; // Font size for selected node info (6-20)
        EmberCore::Color selectedNodeInfoColor = EmberCore::Color(100, 150, 255); // Selected node info text color
        TextAnchor selectedNodeInfoAnchor = TextAnchor::TopLeft;                  // Anchor position
        int selectedNodeInfoX = 10;                                               // X offset from anchor (0-9999)
        int selectedNodeInfoY = 54;                                               // Y offset from anchor (0-9999)
 
        // Debug text - Tree Statistics Info
        bool showTreeInfo = true;                                         // Show tree statistics
        int treeInfoFontSize = 9;                                         // Font size for tree info (6-20)
        EmberCore::Color treeInfoColor = EmberCore::Color(150, 200, 150); // Tree info text color
        TextAnchor treeInfoAnchor = TextAnchor::TopLeft;                  // Anchor position
        int treeInfoX = 10;                                               // X offset from anchor (0-9999)
        int treeInfoY = 74;                                               // Y offset from anchor (0-9999)
 
        // Debug text - FPS Display
        bool showFPS = true;                                         // Show frames per second
        int fpsFontSize = 9;                                         // Font size for FPS (6-20)
        EmberCore::Color fpsColor = EmberCore::Color(255, 200, 100); // FPS text color (orange)
        TextAnchor fpsAnchor = TextAnchor::TopLeft;                  // Anchor position
        int fpsX = 10;                                               // X offset from anchor (0-9999)
        int fpsY = 94;                                               // Y offset from anchor (0-9999)
 
        // Debug text - Controls Help Text
        bool showControlsHelp = true;                                      // Show controls/hotkeys help text
        int controlsHelpFontSize = 11;                                     // Font size for controls help (6-20)
        EmberCore::Color controlsHelpColor = EmberCore::Color(85, 87, 83); // Controls help text color
        TextAnchor controlsHelpAnchor = TextAnchor::BottomLeft;            // Anchor position
        int controlsHelpX = 10;                                            // X offset from anchor (0-9999)
        int controlsHelpY = 25;                                            // Y offset from anchor (0-9999)
    };

    enum class PanelStartupState {
        Show,        // Always show panel on startup
        Hide,        // Always hide panel on startup
        RememberLast // Remember last state
    };

    struct TreeViewSettings {
        bool showHiddenFiles = false;                 // Show hidden files/folders in tree
        bool showFileExtensions = true;               // Show file extensions in tree
        SortBy sortFilesBy = SortBy::Name;            // File sorting method for tree
        TreeItemSize itemSize = TreeItemSize::Medium; // Tree item size (icons and row height)
    };

    enum class LogFontSize { Small = 8, Medium = 10, Large = 12 };

    struct RGBColor {
        int r = 200;
        int g = 200;
        int b = 200;
 
        RGBColor() = default;
        RGBColor(int red, int green, int blue) : r(red), g(green), b(blue) {}
    };

    struct LogTabSettings {
        int defaultLevelFilter = 2;                 // 0=All, 1=Trace, 2=Info, 3=Warning, 4=Error, 5=Critical
        bool autoScrollEnabled = true;              // Auto-scroll to newest logs
        int maxLogEntries = 2000;                   // Maximum log entries to keep
        LogFontSize fontSize = LogFontSize::Medium; // Font size for log list
 
        // Color settings
        bool enableGuiColors = true;     // Enable colored text in LogTab GUI
        bool enableConsoleColors = true; // Enable ANSI colors in console output (spdlog)
 
        // Log level colors (RGB)
        RGBColor traceColor{128, 128, 128};  // Gray
        RGBColor infoColor{100, 200, 100};   // Green
        RGBColor warningColor{230, 180, 50}; // Yellow/Orange
        RGBColor errorColor{230, 80, 80};    // Red
        RGBColor criticalColor{255, 50, 50}; // Bright Red
    };

    struct GridViewSettings {
        bool showHiddenFiles = false;         // Show hidden files/folders in grid
        bool showFileExtensions = true;       // Show file extensions in grid
        SortBy sortFilesBy = SortBy::Name;    // File sorting method for grid
        IconSize iconSize = IconSize::Medium; // Icon size (48, 80, or 128)
    };

    struct BottomPanelSettings {
        // Panel layout settings (percentage of window)
        int defaultPanelHeightPct = 25;                                // Default panel height (% of window)
        bool defaultPanelHeightEnabled = true;                         // Whether default height is enforced
        int minimumPanelHeightPct = 15;                                // Minimum panel height (% of window)
        bool minimumPanelHeightEnabled = true;                         // Whether minimum height is enforced
        PanelStartupState panelStartupState = PanelStartupState::Show; // Panel visibility on startup
        bool lastPanelVisible = true; // Last panel visibility state (for RememberLast feature)
 
        // Tab bar settings
        bool showTabCloseButtons = true; // Show close buttons on tabs
 
        // Behavior settings
        bool rememberLastTab = true;                      // Remember last active tab between sessions
        bool allowPanelCollapse = true;                   // Allow panel collapse via splitter
        EmberCore::String lastActiveTab = "FileExplorer"; // Last active tab (for rememberLastTab feature)
        std::vector<EmberCore::String> lastOpenTabs;      // List of tabs that were open (for rememberLastTab feature)
 
        // File Explorer general settings
        bool showBreadcrumb = true;                                       // Show breadcrumb navigation bar
        bool showHistory = true;                                          // Show navigation history button
        StartPathMode startPathMode = StartPathMode::ExecutableDirectory; // How to determine start path
        EmberCore::String customStartPath = ""; // Custom path when startPathMode is CustomPath
 
        // View-specific settings
        TreeViewSettings treeView;
        GridViewSettings gridView;
 
        // Log tab settings
        LogTabSettings logTab;
    };

    struct SidePanelSettings {
        // Future global settings that affect all side panels (left, right, bottom) will go here
    };

    struct LeftPanelSettings {
        // Panel layout settings (percentage of window)
        int defaultPanelWidthPct = 20;                                 // Default panel width (% of window)
        bool defaultPanelWidthEnabled = true;                          // Whether default width is enforced
        int minimumPanelWidthPct = 10;                                 // Minimum panel width (% of window)
        bool minimumPanelWidthEnabled = true;                          // Whether minimum width is enforced
        PanelStartupState panelStartupState = PanelStartupState::Show; // Panel visibility on startup
        bool lastPanelVisible = true; // Last panel visibility state (for RememberLast feature)
 
        // Tab bar settings
        bool showTabCloseButtons = true; // Show close buttons on tabs
 
        // Behavior settings
        bool rememberLastTab = true;                      // Remember last active tab between sessions
        bool allowPanelCollapse = true;                   // Allow panel collapse via splitter
        EmberCore::String defaultActiveTab = "Navigator"; // Default active tab
        EmberCore::String lastActiveTab = "Navigator";    // Last active tab (for rememberLastTab feature)
        std::vector<EmberCore::String> lastOpenTabs;      // List of tabs that were open (for rememberLastTab feature)
    };

    struct RightPanelSettings {
        // Panel layout settings (percentage of window)
        int defaultPanelWidthPct = 20;                                 // Default panel width (% of window)
        bool defaultPanelWidthEnabled = true;                          // Whether default width is enforced
        int minimumPanelWidthPct = 10;                                 // Minimum panel width (% of window)
        bool minimumPanelWidthEnabled = true;                          // Whether minimum width is enforced
        PanelStartupState panelStartupState = PanelStartupState::Show; // Panel visibility on startup
        bool lastPanelVisible = true; // Last panel visibility state (for RememberLast feature)
 
        // Tab bar settings
        bool showTabCloseButtons = true; // Show close buttons on tabs
 
        // Behavior settings
        bool rememberLastTab = true;                       // Remember last active tab between sessions
        bool allowPanelCollapse = true;                    // Allow panel collapse via splitter
        EmberCore::String defaultActiveTab = "Properties"; // Default active tab
        EmberCore::String lastActiveTab = "Properties";    // Last active tab (for rememberLastTab feature)
        std::vector<EmberCore::String> lastOpenTabs;       // List of tabs that were open (for rememberLastTab feature)
    };

    struct ParserSettings {
        bool autoLoadLastFile = false;                   // Auto-load last file on startup
        EmberCore::String lastOpenedFilePath = "";       // Last opened file path
        EmberCore::String defaultFileEncoding = "UTF-8"; // Default encoding
        bool showParseWarnings = true;                   // Show parsing warnings
    };

    struct PerformanceSettings {
        // Rendering settings (wxWidgets-supported)
        bool enableVSync = true;              // Enable vertical sync (OpenGL contexts)
        FPSLimit fpsLimit = FPSLimit::FPS_60; // Frame rate limit
        bool hardwareAcceleration = true;     // Enable GPU acceleration (OpenGL contexts)
        bool enableDoubleBuffering = true;    // Double buffering for flicker reduction
        bool enableAntiAliasing = true;       // Anti-aliasing for graphics (wxGraphicsContext)
        bool enableTextAntiAliasing = true;   // Text anti-aliasing (font flags)
        bool enablePartialRedraws = true;     // Only redraw changed areas (window style)
        bool enableBackgroundErase = false;   // Erase background before paint (disable for performance)
 
        // Viewport culling settings (for large trees)
        bool enableViewportCulling = true; // Enable viewport culling optimization
        int viewportCullingMargin = 500;   // Culling safety margin in screen pixels (100-1000)
 
        // UI responsiveness settings
        bool enableIdleProcessing = true; // Process idle events
    };
 
  public:
    AppPreferences();
    ~AppPreferences() = default;
 
    // Settings access
    WindowSettings &GetWindowSettings() { return windowSettings_; }
    const WindowSettings &GetWindowSettings() const { return windowSettings_; }
 
    MainPanelSettings &GetMainPanelSettings() { return mainPanelSettings_; }
    const MainPanelSettings &GetMainPanelSettings() const { return mainPanelSettings_; }
 
    BehaviorTreeViewSettings &GetBehaviorTreeViewSettings() { return behaviorTreeViewSettings_; }
    const BehaviorTreeViewSettings &GetBehaviorTreeViewSettings() const { return behaviorTreeViewSettings_; }
 
    BottomPanelSettings &GetBottomPanelSettings() { return bottomPanelSettings_; }
    const BottomPanelSettings &GetBottomPanelSettings() const { return bottomPanelSettings_; }
 
    SidePanelSettings &GetSidePanelSettings() { return sidePanelSettings_; }
    const SidePanelSettings &GetSidePanelSettings() const { return sidePanelSettings_; }
 
    LeftPanelSettings &GetLeftPanelSettings() { return leftPanelSettings_; }
    const LeftPanelSettings &GetLeftPanelSettings() const { return leftPanelSettings_; }
 
    RightPanelSettings &GetRightPanelSettings() { return rightPanelSettings_; }
    const RightPanelSettings &GetRightPanelSettings() const { return rightPanelSettings_; }
 
    ParserSettings &GetParserSettings() { return parserSettings_; }
    const ParserSettings &GetParserSettings() const { return parserSettings_; }
 
    PerformanceSettings &GetPerformanceSettings() { return performanceSettings_; }
    const PerformanceSettings &GetPerformanceSettings() const { return performanceSettings_; }
 
    // Configuration management
    void ResetToDefaults();
    bool LoadFromFile(const EmberCore::String &filename);
    bool SaveToFile(const EmberCore::String &filename) const;
 
    // Helper to get default config path
    static EmberCore::String GetDefaultConfigPath();
 
  private:
    WindowSettings windowSettings_;
    MainPanelSettings mainPanelSettings_;
    BehaviorTreeViewSettings behaviorTreeViewSettings_;
    BottomPanelSettings bottomPanelSettings_;
    SidePanelSettings sidePanelSettings_;
    LeftPanelSettings leftPanelSettings_;
    RightPanelSettings rightPanelSettings_;
    ParserSettings parserSettings_;
    PerformanceSettings performanceSettings_;
 
    // Helper methods for enum conversion
    static ThemeMode StringToThemeMode(const std::string &str);
    static std::string ThemeModeToString(ThemeMode mode);
    static StartupMode StringToStartupMode(const std::string &str);
    static std::string StartupModeToString(StartupMode mode);
    static SortBy StringToSortBy(const std::string &str);
    static std::string SortByToString(SortBy sort);
    static IconSize StringToIconSize(const std::string &str);
    static std::string IconSizeToString(IconSize size);
    static TreeItemSize StringToTreeItemSize(const std::string &str);
    static std::string TreeItemSizeToString(TreeItemSize size);
    static LogFontSize StringToLogFontSize(const std::string &str);
    static std::string LogFontSizeToString(LogFontSize size);
    static StartPathMode StringToStartPathMode(const std::string &str);
    static std::string StartPathModeToString(StartPathMode mode);
    static FPSLimit StringToFPSLimit(const std::string &str);
    static std::string FPSLimitToString(FPSLimit limit);
    static CloseConfirmationMode StringToCloseConfirmationMode(const std::string &str);
    static std::string CloseConfirmationModeToString(CloseConfirmationMode mode);
    static PanelStartupState StringToPanelStartupState(const std::string &str);
    static std::string PanelStartupStateToString(PanelStartupState state);
};

class AppPreferencesManager {
  public:
    static AppPreferencesManager &GetInstance();
 
    AppPreferences &GetPreferences() { return preferences_; }
    const AppPreferences &GetPreferences() const { return preferences_; }

    static wxColour GetAccentColor();
 
  private:
    AppPreferencesManager() = default;
    AppPreferences preferences_;
};
 
} // namespace EmberForge