settings_panel.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SHELL_WINDOWS_SETTINGS_PANEL_H_
#define YAZE_APP_EDITOR_SHELL_WINDOWS_SETTINGS_PANEL_H_
 
#include <array>
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/editor/menu/status_bar.h"
#include "app/editor/system/session/user_settings.h"
#include "app/gui/core/theme_manager.h"
#include "core/patch/patch_manager.h"
#include "core/project.h"
 
namespace yaze {
 
class Rom;
 
namespace editor {
 
class WorkspaceWindowManager;
class ShortcutManager;
class SettingsPanelTestPeer;
 
class SettingsPanel : public Editor {
 public:
  enum class Scope {
    kApplication,
    kWorkspace,
    kProject,
  };
 
  struct CategoryDescriptor {
    const char* id;
    const char* label;
    const char* icon;
    Scope scope;
    const char* keywords;
  };
 
  using OpenMinecartTracksCallback = std::function<absl::Status()>;
 
  SettingsPanel() { type_ = EditorType::kSettings; }
 
  void SetDependencies(const EditorDependencies& deps) override;
 
  void Initialize() override {}
  absl::Status Load() override { return absl::OkStatus(); }
  absl::Status Save() override { return absl::OkStatus(); }
  absl::Status Update() override {
    Draw();
    return absl::OkStatus();
  }
 
  absl::Status Undo() override { return absl::OkStatus(); }
  absl::Status Redo() override { return absl::OkStatus(); }
  absl::Status Cut() override { return absl::OkStatus(); }
  absl::Status Copy() override { return absl::OkStatus(); }
  absl::Status Paste() override { return absl::OkStatus(); }
  absl::Status Find() override { return absl::OkStatus(); }
  // Edit-menu actions are no-ops for the settings editor.
  bool CanUndo() const override { return false; }
  bool CanRedo() const override { return false; }
  bool CanCut() const override { return false; }
  bool CanCopy() const override { return false; }
  bool CanPaste() const override { return false; }
 
  void SetUserSettings(UserSettings* settings) { user_settings_ = settings; }
  void SetWindowManager(WorkspaceWindowManager* registry) {
    window_manager_ = registry;
  }
  void SetShortcutManager(ShortcutManager* manager) {
    shortcut_manager_ = manager;
  }
  void SetStatusBar(StatusBar* bar) { status_bar_ = bar; }
  void SetRom(Rom* rom) { rom_ = rom; }
  void SetProject(project::YazeProject* project) { project_ = project; }
  void SetOpenMinecartTracksCallback(OpenMinecartTracksCallback callback) {
    open_minecart_tracks_callback_ = std::move(callback);
  }
 
  // Resolve the active project and its save-policy identity at draw time.
  void SetProjectContextProvider(
      std::function<project::YazeProject*()> project_provider,
      std::function<std::string()> hash_provider) {
    project_provider_ = std::move(project_provider);
    rom_hash_provider_ = std::move(hash_provider);
  }
 
  // Main draw entry point
  void Draw();
 
  static std::vector<CategoryDescriptor> FilterCategories(
      Scope scope, const std::string& query);
 
 private:
  void DrawScopeTabs();
  void DrawCategoryNavigation(const std::vector<CategoryDescriptor>& categories,
                              bool compact);
  void DrawCategoryContent(const std::string& category_id);
  void EnsureActiveCategory(const std::vector<CategoryDescriptor>& categories);
 
  friend class SettingsPanelTestPeer;
 
  using DungeonOverlaySummary = std::array<std::pair<std::string, bool>, 5>;
 
  void DrawGeneralSettings();
  void DrawAppearanceSettings();
  // Switches the active theme to `preset` density. Lives outside the combo
  // callback so it can be tested: the combo is one line, but the behaviour
  // that matters — routing through ReapplyTheme so Classic YAZE repaints via
  // ColorsYaze() rather than its struct — is not reachable from a unit test
  // while it is buried in an ImGui interaction.
  void ApplyDisplayDensity(gui::DensityPreset preset);
  void DrawWorkspaceSettings();
  // Loads `name` from UserSettings::named_layouts, validates the
  // serialized DockTree, and applies it to the live main dockspace via
  // LayoutManager. Surface for the Workspace section's combo + Re-apply
  // button. On success, persists `last_applied_layout_name = name` so a
  // subsequent startup reapplies the same layout (mirrors the
  // theme-persistence pattern shipped in Phase 5.1). Status is reported
  // via workspace_status_message_.
  void ApplyNamedLayoutToDockspace(const std::string& name);
  void DrawEditorBehavior();
  void DrawPerformanceSettings();
  void DrawAIAgentSettings();
  void DrawFilesystemSettings();
  void DrawKeyboardShortcuts();
  void DrawGlobalShortcuts();
  void DrawEditorShortcuts();
  void DrawPanelShortcuts();
  bool MatchesShortcutFilter(const std::string& text) const;
  void DrawPatchSettings();
  void DrawProjectSettings();  // New method
  void DrawPatchList(const std::string& folder);
  void DrawPatchDetails();
  void DrawParameterWidget(core::PatchParameter* param);
  static DungeonOverlaySummary BuildDungeonOverlaySummary(
      const project::DungeonOverlaySettings& overlay);
  absl::Status RequestOpenMinecartTracks();
 
  UserSettings* user_settings_ = nullptr;
  WorkspaceWindowManager* window_manager_ = nullptr;
  ShortcutManager* shortcut_manager_ = nullptr;
  StatusBar* status_bar_ = nullptr;
  std::function<project::YazeProject*()> project_provider_;
  std::function<std::string()> rom_hash_provider_;
  Rom* rom_ = nullptr;
  project::YazeProject* project_ = nullptr;  // Project reference
 
  // Shortcut editing state
  char shortcut_edit_buffer_[64] = {};
  std::string editing_card_id_;
  bool is_editing_shortcut_ = false;
  std::string shortcut_filter_;
 
  // Patch system state
  core::PatchManager patch_manager_;
  std::string selected_folder_;
  core::AsmPatch* selected_patch_ = nullptr;
  bool patches_loaded_ = false;
 
  // Workspace layout picker transient status — last apply attempt's
  // outcome, drawn beneath the section. Persists across frames within a
  // session; cleared on the next apply attempt.
  std::string workspace_status_message_;
  bool workspace_status_is_error_ = false;
 
  OpenMinecartTracksCallback open_minecart_tracks_callback_;
  std::string project_status_message_;
 
  Scope active_scope_ = Scope::kApplication;
  std::string active_category_ = "appearance";
  std::array<char, 128> settings_search_{};
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SHELL_WINDOWS_SETTINGS_PANEL_H_