theme_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_THEME_MANAGER_H
#define YAZE_APP_GUI_THEME_MANAGER_H
 
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/gui/core/color.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
enum class DensityPreset {
  kCompact,     // 0.75x - Dense UI, more content visible
  kNormal,      // 1.0x - Default balanced spacing
  kComfortable  // 1.25x - Spacious, easier to click
};
 
// Default overworld entity marker colors, used when a theme does not declare
// its own. They follow docs/public/developer/architecture.md section 3.4
// (entrances yellow-gold, exits cyan-white, items red, sprites magenta) and
// are the same for every theme: the markers sit on the map's own pixels, not
// on theme surfaces, so they need to read on light and dark map areas alike.
// The boxes are opaque; labels get an outline (CanvasUtils::DrawCanvasText).
struct EntityMarkerDefaults {
  static Color Entrance() { return {1.0f, 0.8f, 0.0f, 1.0f}; }  // 255,204,0
  static Color Hole() {
    return {1.0f, 150.0f / 255.0f, 0.0f, 1.0f};  // 255,150,0 amber
  }
  static Color Exit() {
    return {150.0f / 255.0f, 235.0f / 255.0f, 1.0f, 1.0f};  // 150,235,255
  }
  static Color Item() {
    return {235.0f / 255.0f, 45.0f / 255.0f, 45.0f / 255.0f, 1.0f};
  }
  static Color Sprite() {
    return {235.0f / 255.0f, 60.0f / 255.0f, 235.0f / 255.0f, 1.0f};
  }
};
 
struct Theme {
  std::string name;
  std::string description;
  std::string author;
 
  // Primary colors
  Color primary;
  Color secondary;
  Color accent;
  Color background;
  Color surface;
  Color error;
  Color warning;
  Color success;
  Color info;
 
  // Text colors
  Color text_primary;
  Color text_secondary;
  Color text_disabled;
 
  // Window colors
  Color window_bg;
  Color child_bg;
  Color popup_bg;
  Color modal_bg;
 
  // Interactive elements
  Color button;
  Color button_hovered;
  Color button_active;
  Color frame_bg;
  Color frame_bg_hovered;
  Color frame_bg_active;
 
  // Navigation and selection
  Color header;
  Color header_hovered;
  Color header_active;
  Color tab;
  Color tab_hovered;
  Color tab_active;
  Color menu_bar_bg;
  Color title_bg;
  Color title_bg_active;
  Color title_bg_collapsed;
 
  // Borders and separators
  Color border;
  Color border_shadow;
  Color separator;
  Color separator_hovered;
  Color separator_active;
 
  // Scrollbars and controls
  Color scrollbar_bg;
  Color scrollbar_grab;
  Color scrollbar_grab_hovered;
  Color scrollbar_grab_active;
 
  // Special elements
  Color resize_grip;
  Color resize_grip_hovered;
  Color resize_grip_active;
  Color docking_preview;
  Color docking_empty_bg;
 
  // Complete ImGui color support
  Color check_mark;
  Color slider_grab;
  Color slider_grab_active;
  Color input_text_cursor;
  Color nav_cursor;
  Color nav_windowing_highlight;
  Color nav_windowing_dim_bg;
  Color modal_window_dim_bg;
  Color text_selected_bg;
  Color drag_drop_target;
  Color table_header_bg;
  Color table_border_strong;
  Color table_border_light;
  Color table_row_bg;
  Color table_row_bg_alt;
  Color text_link;
  Color plot_lines;
  Color plot_lines_hovered;
  Color plot_histogram;
  Color plot_histogram_hovered;
  Color tree_lines;
 
  // Additional ImGui colors for complete coverage
  Color tab_unfocused;
  Color tab_unfocused_active;
  Color tab_dimmed;
  Color tab_dimmed_selected;
  Color tab_dimmed_selected_overline;
  Color tab_selected_overline;
 
  // Enhanced theme system - semantic colors
  Color text_highlight;   // For selected text, highlighted items
  Color link_hover;       // For hover state of links
  Color code_background;  // For code blocks, monospace text backgrounds
  Color success_light;    // Lighter variant of success color
  Color warning_light;    // Lighter variant of warning color
  Color error_light;      // Lighter variant of error color
  Color info_light;       // Lighter variant of info color
 
  // UI state colors
  Color active_selection;  // For active/selected UI elements
  Color hover_highlight;   // General hover state
  Color focus_border;      // For focused input elements
  Color disabled_overlay;  // Semi-transparent overlay for disabled elements
 
  // Editor-specific colors
  Color editor_background;  // Main editor canvas background
  Color editor_grid;        // Grid lines in editors
  Color editor_cursor;      // Cursor/selection in editors
  Color editor_selection;   // Selected area in editors
 
  // Unified selection and interaction colors (replacing hardcoded values)
  Color selection_primary;     // Primary selection (typically gold/yellow)
  Color selection_secondary;   // Secondary selection (typically cyan/blue)
  Color selection_hover;       // Hover highlight color
  Color selection_pulsing;     // Pulsing animation color
  Color selection_handle;      // Corner handles for resizing/moving
  Color drag_preview;          // Ghost preview when dragging
  Color drag_preview_outline;  // Outline for drag preview
 
  // Map entity marker colors. Each is its own token, keyed in .theme files by
  // the field name. The overworld marker defaults are fixed values (see
  // EntityMarkerDefaults), not the status colors: an exit is not an error.
  Color entrance_color;
  Color hole_color;
  Color exit_color;
  Color item_color;
  Color sprite_color;
  Color transport_color;
  Color music_zone_color;
 
  // Nested struct for dungeon editor colors
  struct DungeonColors {
    Color selection_primary;     // Yellow selection
    Color selection_secondary;   // Cyan selection
    Color selection_pulsing;     // Animated pulse
    Color selection_handle;      // Corner handles
    Color drag_preview;          // Semi-transparent drag
    Color drag_preview_outline;  // Drag preview outline
    Color object_wall;
    Color object_floor;
    Color object_chest;  // Gold
    Color object_door;
    Color object_pot;
    Color object_stairs;
    Color object_decoration;
    Color object_default;
    Color grid_cell_highlight;
    Color grid_cell_selected;
    Color grid_cell_border;
    Color grid_text;
    Color room_border;
    Color room_border_dark;
    Color sprite_layer0;  // Green
    Color sprite_layer1;  // Blue
    Color sprite_layer2;
    Color outline_layer0;  // Red
    Color outline_layer1;  // Green
    Color outline_layer2;  // Blue
  } dungeon;
 
  // Nested struct for chat/agent colors
  struct AgentTheme {
    Color user_message;
    Color agent_message;
    Color system_message;
    Color text_secondary;
 
    Color json_text;
    Color command_text;
    Color code_background;
 
    Color panel_bg;
    Color panel_bg_darker;
    Color panel_border;
    Color accent;
 
    Color status_active;
    Color status_inactive;
    Color status_success;
    Color status_warning;
    Color status_error;
 
    Color provider_ollama;
    Color provider_gemini;
    Color provider_mock;
    Color provider_openai;
 
    Color collaboration_active;
    Color collaboration_inactive;
 
    Color proposal_panel_bg;
    Color proposal_accent;
 
    Color button_copy;
    Color button_copy_hover;
 
    Color gradient_top;
    Color gradient_bottom;
  } agent;
 
  // Style parameters
  float window_rounding = 2.0f;
  float frame_rounding = 4.0f;
  float scrollbar_rounding = 4.0f;
  float grab_rounding = 3.0f;
  float tab_rounding = 3.0f;
  float window_border_size = 1.0f;
  float frame_border_size = 1.0f;
 
  // Animation and effects
  bool enable_animations = true;
  float animation_speed = 1.0f;
  bool enable_glow_effects = false;
 
  // Theme-aware sizing system (relative to font size)
  // compact_factor: 0.8 = very compact, 1.0 = normal, 1.2 = spacious
  float compact_factor = 1.0f;
  DensityPreset density_preset = DensityPreset::kNormal;
 
  // Semantic sizing multipliers (applied on top of compact_factor)
  float widget_height_multiplier = 1.0f;     // Standard widget height
  float spacing_multiplier = 1.0f;           // Padding/margins between elements
  float toolbar_height_multiplier = 0.8f;    // Compact toolbars
  float panel_padding_multiplier = 1.0f;     // Panel interior padding
  float input_width_multiplier = 1.0f;       // Standard input field width
  float button_padding_multiplier = 1.0f;    // Button interior padding
  float table_row_height_multiplier = 1.0f;  // Table row height
  float canvas_toolbar_multiplier = 0.75f;   // Canvas overlay toolbars
 
  // Helper methods
  void ApplyToImGui() const;
  // Writes only the density-derived padding/spacing scalars. ApplyToImGui
  // calls it; ApplyClassicYazeTheme calls it separately because ColorsYaze()
  // hardcodes those scalars at the Normal scale.
  void ApplyDensitySizingToImGui() const;
  void ApplyDensityPreset(DensityPreset preset);
};
 
class ThemeManager {
 public:
  static ThemeManager& Get();
 
  // Theme management
  absl::Status LoadTheme(const std::string& theme_name);
  absl::Status SaveTheme(const Theme& theme, const std::string& filename);
  absl::Status LoadThemeFromFile(const std::string& filepath);
  // Non-const: records the chosen filepath in theme_file_paths_ on success so
  // subsequent GetCurrentThemeFilePath calls round-trip for themes created or
  // renamed via the save dialog (not just ones that were loaded from disk).
  absl::Status SaveThemeToFile(const Theme& theme, const std::string& filepath);
 
  // Dynamic theme discovery - replaces hardcoded theme lists with automatic
  // discovery This works across development builds, macOS app bundles, and
  // other deployment scenarios
  std::vector<std::string> DiscoverAvailableThemeFiles() const;
  absl::Status LoadAllAvailableThemes();
  absl::Status RefreshAvailableThemes();  // Public method to refresh at runtime
 
  // Built-in themes
  void InitializeBuiltInThemes();
  std::vector<std::string> GetAvailableThemes() const;
  const Theme* GetTheme(const std::string& name) const;
  const Theme& GetCurrentTheme() const { return current_theme_; }
  const std::string& GetCurrentThemeName() const { return current_theme_name_; }
 
  // Filesystem path the current theme was loaded from (or last saved to via
  // SaveThemeToFile). Returns empty string for Classic YAZE (no file) or when
  // no file association exists; "Save Over Current" uses this to decide
  // whether the overwrite action is available.
  std::string GetCurrentThemeFilePath() const;
 
  // Theme application
  void ApplyTheme(const std::string& theme_name);
  void ApplyTheme(const Theme& theme);
  // Re-apply `theme` as the canonical version of the theme it names. Unlike
  // ApplyTheme(const Theme&), which paints whatever struct it is handed (the
  // theme editor's in-progress edits go through that), this routes Classic
  // YAZE back to ApplyClassicYazeTheme() because BuildClassicYazeTheme's
  // struct cannot reproduce ColorsYaze(). Use it on restore/re-apply paths:
  // EndPreview, live-preview cancel, and the Display Density combo.
  void ReapplyTheme(const Theme& theme);
  // Apply the original ColorsYaze() function. `density` overrides the density
  // carried over from the outgoing theme — ApplyTheme(const Theme&) passes the
  // incoming struct's preset so the Display Density combo still works while
  // Classic YAZE is active.
  void ApplyClassicYazeTheme(
      std::optional<DensityPreset> density = std::nullopt);
 
  // Theme-changed callback. Fired after any successful theme application with
  // the current theme name. Keeps persistence decoupled from ThemeManager —
  // the editor wires this to UserSettings so the selection survives restart.
  using ThemeChangedCallback = std::function<void(const std::string&)>;
  void SetOnThemeChangedCallback(ThemeChangedCallback callback) {
    on_theme_changed_ = std::move(callback);
  }
 
  // Theme preview (for hover preview in selector)
  void StartPreview(const std::string& theme_name);
  void EndPreview();
  bool IsPreviewActive() const;
 
  // Smooth theme transitions
  void UpdateTransition();
  bool IsTransitioning() const { return transitioning_; }
 
  // Theme creation and editing
  Theme CreateCustomTheme(const std::string& name);
  void ShowThemeEditor(bool* p_open);
  void ShowThemeSelector(bool* p_open);
  void ShowSimpleThemeEditor(bool* p_open);
 
  // Accent color derivation - generate harmonious theme from single color
  Theme GenerateThemeFromAccent(const Color& accent, bool dark_mode = true);
  void ApplyAccentColor(const Color& accent, bool dark_mode = true);
 
  // Integration with welcome screen
  Color GetWelcomeScreenBackground() const;
  Color GetWelcomeScreenBorder() const;
  Color GetWelcomeScreenAccent() const;
 
  // Export current theme as JSON string for Web/WASM sync
  std::string ExportCurrentThemeJson() const;
 
  // Convenient theme color access interface
  Color GetThemeColor(const std::string& color_name) const;
  ImVec4 GetThemeColorVec4(const std::string& color_name) const;
 
  // Material Design color accessors
  Color GetPrimary() const { return current_theme_.primary; }
  Color GetPrimaryHover() const { return current_theme_.button_hovered; }
  Color GetPrimaryActive() const { return current_theme_.button_active; }
  Color GetSecondary() const { return current_theme_.secondary; }
  Color GetSurface() const { return current_theme_.surface; }
  Color GetSurfaceVariant() const { return current_theme_.child_bg; }
  Color GetSurfaceContainer() const { return current_theme_.popup_bg; }
  Color GetSurfaceContainerHigh() const { return current_theme_.header; }
  Color GetSurfaceContainerHighest() const {
    return current_theme_.header_hovered;
  }
  Color GetOnSurface() const { return current_theme_.text_primary; }
  Color GetOnSurfaceVariant() const { return current_theme_.text_secondary; }
  Color GetOnPrimary() const { return current_theme_.text_primary; }
  Color GetOutline() const { return current_theme_.border; }
  Color GetTextSecondary() const { return current_theme_.text_secondary; }
  Color GetTextDisabled() const { return current_theme_.text_disabled; }
  Color GetShadow() const { return current_theme_.border_shadow; }
 
 private:
  ThemeManager() { InitializeBuiltInThemes(); }
 
  std::map<std::string, Theme> themes_;
  // Display name → filesystem path captured at LoadThemeFromFile time. Lets
  // GetCurrentThemeFilePath return a path that survives display names with
  // spaces/apostrophes (e.g., "Majora's Moon" → majoras_moon.theme).
  std::map<std::string, std::string> theme_file_paths_;
  Theme current_theme_;
  std::string current_theme_name_ = "Classic YAZE";
 
  // Preview state for hover preview in theme selector
  bool preview_active_ = false;
  Theme preview_original_theme_;
  std::string preview_original_name_;
 
  // True while InitializeBuiltInThemes is constructing the singleton. Guards
  // ApplyClassicYazeTheme from calling AgentUI::RefreshTheme, which would
  // recursively re-enter ThemeManager::Get() and abort on __cxa_guard_acquire.
  bool initializing_built_ins_ = false;
 
  // Smooth transition state (lerps ImGui colors per-frame)
  bool transitioning_ = false;
  float transition_progress_ = 0.0f;
  ImVec4 transition_from_[ImGuiCol_COUNT] = {};
  ImVec4 transition_to_[ImGuiCol_COUNT] = {};
 
  // Fires on_theme_changed_ with current_theme_name_. Safe to call when no
  // callback is set (becomes a no-op).
  void NotifyThemeChanged();
 
  ThemeChangedCallback on_theme_changed_;
 
  void CreateFallbackYazeClassic();
  // `declared_keys`, when non-null, receives every recognised key the file
  // actually contained. ApplySmartDefaults needs that to tell "the author
  // omitted this field" from "the author chose black": a default-constructed
  // Color is opaque black, so the two are identical by value.
  absl::Status ParseThemeFile(const std::string& content, Theme& theme,
                              std::set<std::string>* declared_keys = nullptr);
  // Fill missing properties from primary colors. Fields named in
  // `declared_keys` are left exactly as the file set them.
  void ApplySmartDefaults(Theme& theme,
                          const std::set<std::string>& declared_keys = {});
  Color ParseColorFromString(const std::string& color_str) const;
  std::string SerializeTheme(const Theme& theme) const;
 
  // Helper methods for path resolution
  std::vector<std::string> GetThemeSearchPaths() const;
  std::string GetThemesDirectory() const;
  std::string GetUserThemesDirectory() const;  // Returns ~/.yaze/themes/
};
 
// Global convenience functions for easy theme color access
// Material Design color accessors - global convenience functions
inline Color GetThemeColor(const std::string& color_name) {
  return ThemeManager::Get().GetThemeColor(color_name);
}
 
inline ImVec4 GetThemeColorVec4(const std::string& color_name) {
  return ThemeManager::Get().GetThemeColorVec4(color_name);
}
 
// Material Design color accessors
inline Color GetPrimary() {
  return ThemeManager::Get().GetPrimary();
}
inline Color GetPrimaryHover() {
  return ThemeManager::Get().GetPrimaryHover();
}
inline Color GetPrimaryActive() {
  return ThemeManager::Get().GetPrimaryActive();
}
inline Color GetSecondary() {
  return ThemeManager::Get().GetSecondary();
}
inline Color GetSurface() {
  return ThemeManager::Get().GetSurface();
}
inline Color GetSurfaceVariant() {
  return ThemeManager::Get().GetSurfaceVariant();
}
inline Color GetSurfaceContainer() {
  return ThemeManager::Get().GetSurfaceContainer();
}
inline Color GetSurfaceContainerHigh() {
  return ThemeManager::Get().GetSurfaceContainerHigh();
}
inline Color GetSurfaceContainerHighest() {
  return ThemeManager::Get().GetSurfaceContainerHighest();
}
inline Color GetOnSurface() {
  return ThemeManager::Get().GetOnSurface();
}
inline Color GetOnSurfaceVariant() {
  return ThemeManager::Get().GetOnSurfaceVariant();
}
inline Color GetOnPrimary() {
  return ThemeManager::Get().GetOnPrimary();
}
inline Color GetOutline() {
  return ThemeManager::Get().GetOutline();
}
inline Color GetTextSecondary() {
  return ThemeManager::Get().GetTextSecondary();
}
inline Color GetTextDisabled() {
  return ThemeManager::Get().GetTextDisabled();
}
inline Color GetShadow() {
  return ThemeManager::Get().GetShadow();
}
 
// ImVec4 versions for direct ImGui usage
inline ImVec4 GetPrimaryVec4() {
  return ConvertColorToImVec4(GetPrimary());
}
inline ImVec4 GetPrimaryHoverVec4() {
  return ConvertColorToImVec4(GetPrimaryHover());
}
inline ImVec4 GetPrimaryActiveVec4() {
  return ConvertColorToImVec4(GetPrimaryActive());
}
inline ImVec4 GetSurfaceVec4() {
  return ConvertColorToImVec4(GetSurface());
}
inline ImVec4 GetSurfaceVariantVec4() {
  return ConvertColorToImVec4(GetSurfaceVariant());
}
inline ImVec4 GetSurfaceContainerVec4() {
  return ConvertColorToImVec4(GetSurfaceContainer());
}
inline ImVec4 GetSurfaceContainerHighVec4() {
  return ConvertColorToImVec4(GetSurfaceContainerHigh());
}
inline ImVec4 GetSurfaceContainerHighestVec4() {
  return ConvertColorToImVec4(GetSurfaceContainerHighest());
}
inline ImVec4 GetOnSurfaceVec4() {
  return ConvertColorToImVec4(GetOnSurface());
}
inline ImVec4 GetOnSurfaceVariantVec4() {
  return ConvertColorToImVec4(GetOnSurfaceVariant());
}
inline ImVec4 GetOnPrimaryVec4() {
  return ConvertColorToImVec4(GetOnPrimary());
}
inline ImVec4 GetOutlineVec4() {
  return ConvertColorToImVec4(GetOutline());
}
inline ImVec4 GetTextSecondaryVec4() {
  return ConvertColorToImVec4(GetTextSecondary());
}
inline ImVec4 GetTextDisabledVec4() {
  return ConvertColorToImVec4(GetTextDisabled());
}
inline ImVec4 GetTextPrimaryVec4() {
  return ConvertColorToImVec4(
      ThemeManager::Get().GetCurrentTheme().text_primary);
}
inline ImVec4 GetSuccessVec4() {
  return ConvertColorToImVec4(ThemeManager::Get().GetCurrentTheme().success);
}
inline ImVec4 GetWarningVec4() {
  return ConvertColorToImVec4(ThemeManager::Get().GetCurrentTheme().warning);
}
inline ImVec4 GetErrorVec4() {
  return ConvertColorToImVec4(ThemeManager::Get().GetCurrentTheme().error);
}
inline ImVec4 GetShadowVec4() {
  return ConvertColorToImVec4(GetShadow());
}
}  // namespace gui
 
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_THEME_MANAGER_H