ui_coordinator.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SHELL_COORDINATOR_UI_COORDINATOR_H_
#define YAZE_APP_EDITOR_SHELL_COORDINATOR_UI_COORDINATOR_H_
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/editor/shell/coordinator/welcome_screen.h"
#include "app/editor/shell/feedback/popup_manager.h"
#include "app/editor/system/command_palette.h"
#include "app/editor/ui/new_project_dialog.h"
#include "app/gui/core/icons.h"
#include "app/startup_flags.h"
 
namespace yaze {
namespace editor {
 
enum class StartupSurface {
  kWelcome,    // No ROM, showing onboarding
  kDashboard,  // ROM loaded, no active editor
  kEditor,     // Active editor/category
};
 
// Forward declarations to avoid circular dependencies
class EditorManager;
class RomFileManager;
class ProjectManager;
class EditorRegistry;
class SessionCoordinator;
class ToastManager;
class WindowDelegate;
class ShortcutManager;
class WorkspaceWindowManager;
 
class UICoordinator {
 public:
  // Constructor takes references to the managers it coordinates with
  UICoordinator(EditorManager* editor_manager, RomFileManager& rom_manager,
                ProjectManager& project_manager,
                EditorRegistry& editor_registry,
                WorkspaceWindowManager& card_registry,
                SessionCoordinator& session_coordinator,
                WindowDelegate& window_delegate, ToastManager& toast_manager,
                PopupManager& popup_manager, ShortcutManager& shortcut_manager);
  ~UICoordinator() = default;
 
  // Non-copyable due to reference members
  UICoordinator(const UICoordinator&) = delete;
  UICoordinator& operator=(const UICoordinator&) = delete;
 
  // Main UI drawing interface
  void DrawBackground();
  void DrawAllUI();
  void DrawMenuBarExtras();
  // Shared styling for menu-bar icon buttons (hamburger, bell, session, WASM).
  bool DrawMenuBarIconButton(const char* icon, const char* tooltip,
                             bool is_active = false);
  void DrawNotificationBell(bool show_dirty, bool has_dirty_rom,
                            bool show_session, bool has_multiple_sessions);
  void DrawSessionButton();
 
  // Core UI components (actual ImGui rendering moved from EditorManager)
  void DrawCommandPalette();
  void DrawPanelFinder();
  void DrawShortcutsBrowser();
  void DrawGlobalSearch();
  void DrawWorkspacePresetDialogs();
 
  // Session UI components
  void DrawSessionSwitcher();
  void DrawSessionManager();
  void DrawSessionRenameDialog();
  void DrawLayoutPresets();
 
  // Welcome screen and project UI
  void DrawWelcomeScreen();
  void DrawProjectHelp();
  void OpenNewProjectDialog(
      const std::string& initial_template = "Vanilla ROM Hack") {
    new_project_dialog_.Open(initial_template);
  }
  bool IsNewProjectDialogOpen() const { return new_project_dialog_.IsOpen(); }
 
  // Window management UI
  void DrawWindowManagementUI();
 
  // Popup and dialog management
  void DrawAllPopups();
  void ShowPopup(const std::string& popup_name);
  void HidePopup(const std::string& popup_name);
 
  // UI state management
  void ShowEditorSelection() { show_editor_selection_ = true; }
  void ShowDisplaySettings();
  void ShowSaveWorkspacePresetDialog() { show_save_workspace_preset_ = true; }
  void ShowLoadWorkspacePresetDialog() { show_load_workspace_preset_ = true; }
  // Session switcher is now managed by SessionCoordinator
  void ShowSessionSwitcher();
  // Sidebar visibility delegates to WorkspaceWindowManager (single source of truth)
  void TogglePanelSidebar();
  void ShowGlobalSearch() { show_global_search_ = true; }
  void ShowCommandPalette(const char* initial_query = nullptr);
  void ShowPanelFinder();
  void ShowWindowBrowser() { show_panel_browser_ = true; }
  void ShowShortcutsBrowser() { show_shortcuts_browser_ = true; }
 
  void InitializeCommandPalette(size_t session_id);
  void RefreshWorkflowActions();
 
  void RefreshCommandPalette(size_t session_id);
  CommandPalette* command_palette() { return &command_palette_; }
 
  void ExecutePaletteCommand(const std::string& name,
                             std::function<void()> callback);
 
  // Menu bar visibility (for WASM/web app mode)
  bool IsMenuBarVisible() const { return show_menu_bar_; }
  void SetMenuBarVisible(bool visible) { show_menu_bar_ = visible; }
  void ToggleMenuBar() { show_menu_bar_ = !show_menu_bar_; }
 
  // Draw floating menu bar restore button (when menu bar is hidden)
  void DrawMenuBarRestoreButton();
 
  // Window visibility management
  void ShowAllWindows();
  void HideAllWindows();
 
  // UI state queries (EditorManager can check these)
  bool IsEditorSelectionVisible() const { return show_editor_selection_; }
  bool IsDisplaySettingsVisible() const { return show_display_settings_; }
  // Session switcher visibility managed by SessionCoordinator
  bool IsSessionSwitcherVisible() const;
  bool IsWelcomeScreenVisible() const { return show_welcome_screen_; }
  bool IsWelcomeScreenManuallyClosed() const {
    return welcome_screen_manually_closed_;
  }
  bool IsGlobalSearchVisible() const { return show_global_search_; }
  bool IsPerformanceDashboardVisible() const {
    return show_performance_dashboard_;
  }
  bool IsWindowBrowserVisible() const { return show_panel_browser_; }
  bool IsCommandPaletteVisible() const { return show_command_palette_; }
  // Sidebar visibility delegates to WorkspaceWindowManager (single source of truth)
  bool IsPanelSidebarVisible() const;
  bool IsImGuiDemoVisible() const { return show_imgui_demo_; }
  bool IsImGuiMetricsVisible() const { return show_imgui_metrics_; }
  // Emulator + Assembly visibility delegate to WorkspaceWindowManager (single
  // source of truth). Assembly follows the same category-backed pattern as the
  // emulator; there is no per-editor boolean that can drift.
  bool IsEmulatorVisible() const;
  bool IsAsmEditorVisible() const;
  bool IsResourceLabelManagerVisible() const {
    return show_resource_label_manager_;
  }
  bool IsAIAgentVisible() const { return show_ai_agent_; }
  bool IsChatHistoryVisible() const { return show_chat_history_; }
  bool IsProposalDrawerVisible() const { return show_proposal_drawer_; }
 
  // UI state setters (for programmatic control)
  // Automatic entry into the dashboard (ROM load, project load, ROM-options
  // apply). `--startup_dashboard=hide` suppresses exactly this path.
  // Ctrl+E goes through ShowEditorSelection() and is deliberately unaffected:
  // the flag governs startup, not the shortcut.
  void SetEditorSelectionVisible(bool visible) {
    if (visible && !ShouldShowDashboard()) {
      return;
    }
    show_editor_selection_ = visible;
  }
  void SetDisplaySettingsVisible(bool visible) {
    show_display_settings_ = visible;
  }
  // Session switcher state managed by SessionCoordinator
  void SetSessionSwitcherVisible(bool visible);
  void SetWelcomeScreenVisible(bool visible) { show_welcome_screen_ = visible; }
  void SetWelcomeScreenManuallyClosed(bool closed) {
    welcome_screen_manually_closed_ = closed;
  }
  void SetWelcomeScreenBehavior(StartupVisibility mode);
  void SetGlobalSearchVisible(bool visible) { show_global_search_ = visible; }
  void SetPerformanceDashboardVisible(bool visible) {
    show_performance_dashboard_ = visible;
  }
  void SetWindowBrowserVisible(bool visible) { show_panel_browser_ = visible; }
  void SetCommandPaletteVisible(bool visible);
  // Sidebar visibility delegates to WorkspaceWindowManager (single source of truth)
  void SetPanelSidebarVisible(bool visible);
  void SetImGuiDemoVisible(bool visible) { show_imgui_demo_ = visible; }
  void SetImGuiMetricsVisible(bool visible) { show_imgui_metrics_ = visible; }
  // Emulator + Assembly visibility delegate to WorkspaceWindowManager.
  void SetEmulatorVisible(bool visible);
  void SetAsmEditorVisible(bool visible);
  void SetResourceLabelManagerVisible(bool visible) {
    show_resource_label_manager_ = visible;
  }
  void SetDashboardBehavior(StartupVisibility mode);
  void SetAIAgentVisible(bool visible) { show_ai_agent_ = visible; }
 
  // Startup surface management (single source of truth)
  StartupSurface GetCurrentStartupSurface() const {
    return current_startup_surface_;
  }
  void SetStartupSurface(StartupSurface surface);
  bool ShouldShowWelcome() const;
  bool ShouldShowDashboard() const;
  bool ShouldShowActivityBar() const;
  void SetChatHistoryVisible(bool visible) { show_chat_history_ = visible; }
  void SetProposalDrawerVisible(bool visible) {
    show_proposal_drawer_ = visible;
  }
 
  // Note: Theme styling is handled by ThemeManager, not UICoordinator
 
 private:
  // References to coordinated managers
  EditorManager* editor_manager_;
  RomFileManager& rom_manager_;
  ProjectManager& project_manager_;
  EditorRegistry& editor_registry_;
  WorkspaceWindowManager& window_manager_;
  SessionCoordinator& session_coordinator_;
  WindowDelegate& window_delegate_;
  ToastManager& toast_manager_;
  PopupManager& popup_manager_;
  ShortcutManager& shortcut_manager_;
 
  // UI state flags (UICoordinator owns all UI visibility state)
  bool show_editor_selection_ = false;
  bool show_display_settings_ = false;
  // show_session_switcher_ removed - managed by SessionCoordinator
  bool show_welcome_screen_ = true;
  bool welcome_screen_manually_closed_ = false;
  bool show_global_search_ = false;
  bool show_performance_dashboard_ = false;
  bool show_imgui_demo_ = false;
  bool show_imgui_metrics_ = false;
  bool show_test_dashboard_ = false;
  bool show_panel_browser_ = false;
  bool show_panel_finder_ = false;
  bool show_command_palette_ = false;
  bool show_shortcuts_browser_ = false;
  // show_emulator_ removed - now managed by WorkspaceWindowManager
  // show_panel_sidebar_ removed - now managed by WorkspaceWindowManager
  // show_memory_editor_ / show_palette_editor_ removed - dead state, their
  // editors register panels with WorkspaceWindowManager directly.
  // show_asm_editor_ removed - now delegates via GetWindowsInCategory("Assembly")
  bool show_resource_label_manager_ = false;
  bool show_ai_agent_ = false;
  bool show_chat_history_ = false;
  bool show_proposal_drawer_ = false;
  bool show_save_workspace_preset_ = false;
  bool show_load_workspace_preset_ = false;
  bool show_menu_bar_ = true;  // Menu bar visible by default
  StartupVisibility welcome_behavior_override_ = StartupVisibility::kAuto;
  StartupVisibility dashboard_behavior_override_ = StartupVisibility::kAuto;
 
  // Single source of truth for startup surface state
  StartupSurface current_startup_surface_ = StartupSurface::kWelcome;
 
  // Command Palette state
  CommandPalette command_palette_;
  bool command_palette_initialized_ = false;
  bool command_history_loaded_ = false;
  char command_palette_query_[256] = {};
  int command_palette_selected_idx_ = 0;
  bool command_palette_scroll_to_selected_ = false;
  bool command_palette_refocus_input_ = false;
  // Search() cache: recomputed only when the query or palette changes.
  std::string command_palette_cached_query_;
  uint64_t command_palette_cached_generation_ = ~uint64_t{0};
  std::vector<CommandMatch> command_palette_cached_matches_;
 
  void SaveCommandPaletteHistory();
 
  // Window Finder state (legacy modal; ShowPanelFinder now seeds the palette)
  char panel_finder_query_[256] = {};
  int panel_finder_selected_idx_ = 0;
 
  // Shortcuts browser state
  char shortcuts_browser_query_[256] = {};
 
  // Global Search state
  char global_search_query_[256] = {};
 
  // Welcome screen component
  std::unique_ptr<WelcomeScreen> welcome_screen_;
 
  // "New Project" guided dialog. Owned here so it survives welcome-screen
  // visibility transitions during startup.
  NewProjectDialog new_project_dialog_;
 
  // Calculate width of a menubar icon button (icon + frame padding)
  static float GetMenuBarIconButtonWidth();
 
  // Material Design component helpers
  void DrawMaterialButton(const std::string& text, const std::string& icon,
                          const ImVec4& color, std::function<void()> callback,
                          bool enabled = true);
 
  // Mobile helpers
  bool IsCompactLayout() const;
 
  // Layout and positioning helpers
  void CenterWindow(const std::string& window_name);
  void PositionWindow(const std::string& window_name, float x, float y);
  void SetWindowSize(const std::string& window_name, float width, float height);
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SHELL_COORDINATOR_UI_COORDINATOR_H_