dashboard_panel.cc

Go to the documentation of this file.

#include "app/editor/shell/windows/dashboard_panel.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <cfloat>
#include <fstream>
#include <sstream>
 
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "app/editor/system/workspace/editor_manager_interfaces.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/platform_keys.h"
#include "app/gui/core/style.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/widgets/themed_widgets.h"
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
#include "rom/rom.h"
#include "util/file_util.h"
 
namespace yaze {
namespace editor {
 
namespace {
 
constexpr float kDashboardCardBaseWidth = 180.0f;
constexpr float kDashboardCardBaseHeight = 120.0f;
constexpr float kDashboardCardWidthMaxFactor = 1.35f;
constexpr float kDashboardCardHeightMaxFactor = 1.35f;
constexpr float kDashboardCardMinWidthFactor = 0.9f;
constexpr float kDashboardCardMinHeightFactor = 0.9f;
constexpr int kDashboardMaxColumns = 5;
constexpr float kDashboardRecentBaseWidth = 150.0f;
constexpr float kDashboardRecentBaseHeight = 35.0f;
constexpr float kDashboardRecentWidthMaxFactor = 1.3f;
constexpr int kDashboardMaxRecentColumns = 4;
 
struct FlowLayout {
  int columns = 1;
  float item_width = 0.0f;
  float item_height = 0.0f;
  float spacing = 0.0f;
};
 
FlowLayout ComputeFlowLayout(float avail_width, float min_width,
                             float max_width, float min_height,
                             float max_height, float aspect_ratio,
                             float spacing, int max_columns, int item_count) {
  FlowLayout layout;
  layout.spacing = spacing;
  if (avail_width <= 0.0f) {
    layout.columns = 1;
    layout.item_width = min_width;
    layout.item_height = min_height;
    return layout;
  }
 
  const int clamped_max =
      std::max(1, max_columns > 0 ? max_columns : item_count);
  const auto width_for_columns = [avail_width, spacing](int columns) {
    return (avail_width - spacing * static_cast<float>(columns - 1)) /
           static_cast<float>(columns);
  };
 
  int columns = std::max(
      1, static_cast<int>((avail_width + spacing) / (min_width + spacing)));
  columns = std::min(columns, clamped_max);
  if (item_count > 0) {
    columns = std::min(columns, item_count);
  }
  columns = std::max(columns, 1);
 
  float width = width_for_columns(columns);
  while (columns < clamped_max && width > max_width) {
    columns += 1;
    width = width_for_columns(columns);
  }
 
  const float clamped_max_width = std::min(max_width, avail_width);
  const float clamped_min_width = std::min(min_width, clamped_max_width);
  layout.item_width = std::clamp(width, clamped_min_width, clamped_max_width);
  layout.item_height =
      std::clamp(layout.item_width * aspect_ratio, min_height, max_height);
 
  layout.columns = columns;
 
  return layout;
}
 
// Size for an emphasised run of text, as a multiple of the body size.
// FontSizeBase starts at 0 and is resolved on the first frame, and PushFont
// reads 0 as "keep current size", so fall back to the resolved size.
float HeadingFontSize(float multiplier) {
  const float base = ImGui::GetStyle().FontSizeBase > 0.0f
                         ? ImGui::GetStyle().FontSizeBase
                         : ImGui::GetFontSize();
  return base * multiplier;
}
 
// True when the active theme paints on a light ground. Five of the shipped
// presets do (Wind Waker, Forest Light, Midnight Light, Ocean Light,
// Solarized Light); wind_waker.theme says so in its own header comment.
// The Display Density preset's multiplier (0.75 / 1.0 / 1.25). It reaches
// ImGui only through FramePadding/ItemSpacing, so anything sized from a flat
// pixel constant ignores the setting entirely.
float DensityFactor() {
  return std::max(0.1f,
                  gui::ThemeManager::Get().GetCurrentTheme().compact_factor);
}
 
bool OnLightGround() {
  const ImVec4 bg = ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
  return (0.299f * bg.x + 0.587f * bg.y + 0.114f * bg.z) > 0.5f;
}
 
// Shifts `color` away from the text and toward the page, so a card reads as a
// surface sitting behind its own label.
//
// This used to be an unconditional multiply toward black, which is only
// "toward the page" on a dark theme. On the light presets it drove every card
// surface — gradient 0.4/0.2, border 0.6, recent rows 0.5 — to near-black
// while the card's own footer kept drawing in text_secondary, i.e. dark text
// on a dark plate. On a light ground the same scale now moves toward white,
// preserving the intent instead of the arithmetic.
ImVec4 ScaleColor(const ImVec4& color, float scale, float alpha) {
  if (!OnLightGround()) {
    return ImVec4(color.x * scale, color.y * scale, color.z * scale, alpha);
  }
  const float toward_white = 1.0f - std::clamp(scale, 0.0f, 1.0f);
  return ImVec4(color.x + (1.0f - color.x) * toward_white,
                color.y + (1.0f - color.y) * toward_white,
                color.z + (1.0f - color.z) * toward_white, alpha);
}
 
ImVec4 ScaleColor(const ImVec4& color, float scale) {
  return ScaleColor(color, scale, color.w);
}
 
ImVec4 WithAlpha(ImVec4 color, float alpha) {
  color.w = alpha;
  return color;
}
 
ImVec4 GetEditorAccentColor(EditorType type, const gui::Theme& theme) {
  switch (type) {
    case EditorType::kOverworld:
      return gui::ConvertColorToImVec4(theme.success);
    case EditorType::kDungeon:
      return gui::ConvertColorToImVec4(theme.secondary);
    case EditorType::kGraphics:
      return gui::ConvertColorToImVec4(theme.warning);
    case EditorType::kSprite:
      return gui::ConvertColorToImVec4(theme.info);
    case EditorType::kMessage:
      return gui::ConvertColorToImVec4(theme.primary);
    case EditorType::kMusic:
      return gui::ConvertColorToImVec4(theme.accent);
    case EditorType::kPalette:
      return gui::ConvertColorToImVec4(theme.error);
    case EditorType::kScreen:
      return gui::ConvertColorToImVec4(theme.info);
    case EditorType::kAssembly:
      // Every other editor maps to a background/semantic token. text_secondary
      // is a FOREGROUND token, and this value is used as the icon disc's fill
      // with text_primary drawn on top — two text colours stacked.
      return gui::ConvertColorToImVec4(theme.secondary);
    case EditorType::kHex:
      return gui::ConvertColorToImVec4(theme.success);
    case EditorType::kEmulator:
      return gui::ConvertColorToImVec4(theme.info);
    case EditorType::kAgent:
      return gui::ConvertColorToImVec4(theme.accent);
    case EditorType::kSettings:
    case EditorType::kUnknown:
    default:
      return gui::ConvertColorToImVec4(theme.text_primary);
  }
}
 
}  // namespace
 
DashboardPanel::DashboardPanel(IEditorSwitcher* editor_switcher)
    : editor_switcher_(editor_switcher),
      window_("Dashboard", ICON_MD_DASHBOARD) {
  window_.SetSaveSettings(false);
  window_.SetDefaultSize(950, 650);
  window_.SetPosition(gui::PanelWindow::Position::Center);
 
  // Use platform-aware shortcut strings (Cmd on macOS, Ctrl elsewhere)
  const char* ctrl = gui::GetCtrlDisplayName();
  editors_ = {
      {"Overworld", ICON_MD_MAP,
       "Edit overworld maps, entrances, and properties",
       absl::StrFormat("%s+1", ctrl), EditorType::kOverworld},
      {"Dungeon", ICON_MD_CASTLE,
       "Design dungeon rooms, layouts, and mechanics",
       absl::StrFormat("%s+2", ctrl), EditorType::kDungeon},
      {"Graphics", ICON_MD_PALETTE, "Modify tiles, palettes, and graphics sets",
       absl::StrFormat("%s+3", ctrl), EditorType::kGraphics},
      {"Sprites", ICON_MD_EMOJI_EMOTIONS, "Edit sprite graphics and properties",
       absl::StrFormat("%s+4", ctrl), EditorType::kSprite},
      {"Messages", ICON_MD_CHAT_BUBBLE, "Edit dialogue, signs, and text",
       absl::StrFormat("%s+5", ctrl), EditorType::kMessage},
      {"Music", ICON_MD_MUSIC_NOTE, "Configure music and sound effects",
       absl::StrFormat("%s+6", ctrl), EditorType::kMusic},
      {"Palettes", ICON_MD_COLOR_LENS, "Edit color palettes and animations",
       absl::StrFormat("%s+7", ctrl), EditorType::kPalette},
      {"Screens", ICON_MD_TV, "Edit title screen and ending screens",
       absl::StrFormat("%s+8", ctrl), EditorType::kScreen},
      {"Assembly", ICON_MD_CODE, "Write and edit assembly code",
       absl::StrFormat("%s+9", ctrl), EditorType::kAssembly},
      {"Hex Editor", ICON_MD_DATA_ARRAY,
       "Direct ROM memory editing and comparison",
       absl::StrFormat("%s+0", ctrl), EditorType::kHex},
      {"Emulator", ICON_MD_VIDEOGAME_ASSET,
       "Test and debug your ROM in real-time",
       absl::StrFormat("%s+Shift+E", ctrl), EditorType::kEmulator},
      {"AI Agent", ICON_MD_SMART_TOY,
       "Configure AI agent, collaboration, and automation",
       absl::StrFormat("%s+Shift+A", ctrl), EditorType::kAgent, false, false},
  };
 
  LoadRecentEditors();
}
 
void DashboardPanel::Draw() {
  if (!show_)
    return;
 
  // Set window properties immediately before Begin
  ImGuiViewport* viewport = ImGui::GetMainViewport();
  ImVec2 center = viewport->GetCenter();
  ImVec2 view_size = viewport->WorkSize;
  float target_width = std::clamp(view_size.x * 0.9f, 520.0f, 1000.0f);
  float target_height = std::clamp(view_size.y * 0.88f, 420.0f, 780.0f);
  ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
  ImGui::SetNextWindowSize(ImVec2(target_width, target_height),
                           ImGuiCond_Appearing);
  ImGui::SetNextWindowSizeConstraints(
      ImVec2(420.0f, 360.0f), ImVec2(view_size.x * 0.98f, view_size.y * 0.95f));
 
  has_rom_ = editor_switcher_ && editor_switcher_->GetCurrentRom() &&
             editor_switcher_->GetCurrentRom()->is_loaded();
 
  if (window_.Begin(&show_)) {
    DrawWelcomeHeader();
    ImGui::Separator();
    ImGui::Spacing();
 
    if (!has_rom_) {
      const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
      ImVec4 info_color = gui::ConvertColorToImVec4(theme.text_secondary);
      ImGui::TextColored(info_color,
                         ICON_MD_INFO " Load a ROM to enable editors.");
      ImGui::Spacing();
    }
 
    DrawRecentEditors();
    if (!recent_editors_.empty()) {
      ImGui::Separator();
      ImGui::Spacing();
    }
    DrawEditorGrid();
  }
  window_.End();
}
 
void DashboardPanel::DrawWelcomeHeader() {
  const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
  const ImVec4 accent = gui::ConvertColorToImVec4(theme.accent);
  const ImVec4 text_secondary = gui::ConvertColorToImVec4(theme.text_secondary);
 
  // Scale the current face rather than indexing the atlas. Every font in the
  // registry loads at the same size and the icon/Japanese passes merge into
  // the previous face instead of appending, so Fonts[2] was Cousine — a
  // monospace code face at body size. The heading got a typeface swap nobody
  // asked for, no size change, and an unchecked index into a vector whose
  // length depends on which fonts actually loaded.
  ImGui::PushFont(nullptr, HeadingFontSize(1.4f));
  ImGui::TextColored(accent, ICON_MD_EDIT " Select an Editor");
  ImGui::PopFont();
 
  ImGui::TextColored(text_secondary,
                     tr("Choose an editor to begin working on your ROM. "
                        "You can open multiple editors simultaneously."));
}
 
void DashboardPanel::DrawRecentEditors() {
  if (recent_editors_.empty())
    return;
 
  const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
  const ImVec4 accent = gui::ConvertColorToImVec4(theme.accent);
  ImGui::TextColored(accent, ICON_MD_HISTORY " Recently Used");
  ImGui::Spacing();
 
  const ImGuiStyle& style = ImGui::GetStyle();
  const float avail_width = ImGui::GetContentRegionAvail().x;
  const float min_width = kDashboardRecentBaseWidth;
  const float max_width =
      kDashboardRecentBaseWidth * kDashboardRecentWidthMaxFactor;
  // Additive, like welcome_screen's recent rows: a flat floor of 35 sat above
  // GetFrameHeight()'s entire 22/24/26 range, so Compact, Normal and
  // Comfortable all produced the identical row.
  const float height = ImGui::GetFrameHeight() + 10.0f * DensityFactor();
  const float spacing = style.ItemSpacing.x;
  const bool stack_items = avail_width < min_width * 1.6f;
  FlowLayout row_layout{};
  if (stack_items) {
    row_layout.columns = 1;
    row_layout.item_width = avail_width;
    row_layout.item_height = height;
    row_layout.spacing = spacing;
  } else {
    row_layout = ComputeFlowLayout(avail_width, min_width, max_width, height,
                                   height, height / std::max(min_width, 1.0f),
                                   spacing, kDashboardMaxRecentColumns,
                                   static_cast<int>(recent_editors_.size()));
  }
 
  ImGuiTableFlags table_flags =
      ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_NoPadOuterX;
  const ImVec2 cell_padding(row_layout.spacing * 0.5f,
                            style.ItemSpacing.y * 0.4f);
  gui::StyleVarGuard cell_var_guard(ImGuiStyleVar_CellPadding, cell_padding);
  if (ImGui::BeginTable("DashboardRecentGrid", row_layout.columns,
                        table_flags)) {
    for (EditorType type : recent_editors_) {
      // Find editor info
      auto it = std::find_if(
          editors_.begin(), editors_.end(),
          [type](const EditorInfo& info) { return info.type == type; });
 
      if (it == editors_.end()) {
        continue;
      }
 
      ImGui::TableNextColumn();
 
      const bool enabled = has_rom_ || !it->requires_rom;
      const float alpha = enabled ? 1.0f : 0.35f;
      const ImVec4 base_color = GetEditorAccentColor(it->type, theme);
      gui::StyleColorGuard btn_guard(
          {{ImGuiCol_Button, ScaleColor(base_color, 0.5f, 0.7f * alpha)},
           {ImGuiCol_ButtonHovered, ScaleColor(base_color, 0.7f, 0.9f * alpha)},
           {ImGuiCol_ButtonActive, WithAlpha(base_color, 1.0f * alpha)}});
 
      ImVec2 button_size(
          stack_items ? avail_width : row_layout.item_width,
          row_layout.item_height > 0.0f ? row_layout.item_height : height);
      if (!enabled) {
        ImGui::BeginDisabled();
      }
      if (ImGui::Button(absl::StrCat(it->icon, " ", it->name).c_str(),
                        button_size)) {
        if (enabled && editor_switcher_) {
          MarkRecentlyUsed(type);
          editor_switcher_->SwitchToEditor(type);
          editor_switcher_->DismissEditorSelection();
          show_ = false;
        }
      }
      if (!enabled) {
        ImGui::EndDisabled();
      }
 
      if (ImGui::IsItemHovered()) {
        if (!enabled) {
          ImGui::SetTooltip(tr("Load a ROM to open %s"), it->name.c_str());
        } else {
          ImGui::SetTooltip("%s", it->description.c_str());
        }
      }
    }
    ImGui::EndTable();
  }
}
 
void DashboardPanel::DrawEditorGrid() {
  ImGui::Text(ICON_MD_APPS " All Editors");
  ImGui::Spacing();
 
  const ImGuiStyle& style = ImGui::GetStyle();
  const float avail_width = ImGui::GetContentRegionAvail().x;
  const float scale = ImGui::GetFontSize() / 16.0f;
  // compact_scale responds to available WIDTH; `scale` responds to font size.
  // Neither is the Display Density preset, so fold it in explicitly.
  const float compact_scale =
      (avail_width < 620.0f ? 0.85f : 1.0f) * DensityFactor();
  const float min_width = kDashboardCardBaseWidth *
                          kDashboardCardMinWidthFactor * scale * compact_scale;
  const float max_width = kDashboardCardBaseWidth *
                          kDashboardCardWidthMaxFactor * scale * compact_scale;
  const float min_height =
      std::max(kDashboardCardBaseHeight * kDashboardCardMinHeightFactor *
                   scale * compact_scale,
               ImGui::GetFrameHeight() * 3.2f);
  const float max_height = kDashboardCardBaseHeight *
                           kDashboardCardHeightMaxFactor * scale *
                           compact_scale;
  const float aspect_ratio =
      kDashboardCardBaseHeight / std::max(kDashboardCardBaseWidth, 1.0f);
  const float spacing = style.ItemSpacing.x;
 
  FlowLayout layout = ComputeFlowLayout(
      avail_width, min_width, max_width, min_height, max_height, aspect_ratio,
      spacing, kDashboardMaxColumns, static_cast<int>(editors_.size()));
 
  ImGuiTableFlags table_flags =
      ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_NoPadOuterX;
  const ImVec2 cell_padding(layout.spacing * 0.5f, style.ItemSpacing.y * 0.5f);
  gui::StyleVarGuard grid_var_guard(ImGuiStyleVar_CellPadding, cell_padding);
  if (ImGui::BeginTable("DashboardEditorGrid", layout.columns, table_flags)) {
    for (size_t i = 0; i < editors_.size(); ++i) {
      ImGui::TableNextColumn();
      const bool enabled = has_rom_ || !editors_[i].requires_rom;
      DrawEditorPanel(editors_[i], static_cast<int>(i),
                      ImVec2(layout.item_width, layout.item_height), enabled);
    }
    ImGui::EndTable();
  }
}
 
void DashboardPanel::DrawEditorPanel(const EditorInfo& info, int index,
                                     const ImVec2& card_size, bool enabled) {
  ImGui::PushID(index);
 
  const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
  const float disabled_alpha = enabled ? 1.0f : 0.35f;
  const ImVec4 base_color = GetEditorAccentColor(info.type, theme);
  ImVec4 text_primary = gui::ConvertColorToImVec4(theme.text_primary);
  ImVec4 text_secondary = gui::ConvertColorToImVec4(theme.text_secondary);
  const ImVec4 accent = gui::ConvertColorToImVec4(theme.accent);
  text_primary.w *= enabled ? 1.0f : 0.5f;
  text_secondary.w *= enabled ? 1.0f : 0.5f;
  ImFont* text_font = ImGui::GetFont();
  const float text_font_size = ImGui::GetFontSize();
 
  const ImGuiStyle& style = ImGui::GetStyle();
  const float line_height = ImGui::GetTextLineHeight();
  const float padding_x = std::max(style.FramePadding.x, card_size.x * 0.06f);
  const float padding_y = std::max(style.FramePadding.y, card_size.y * 0.08f);
 
  const float footer_height = info.shortcut.empty() ? 0.0f : line_height;
  const float footer_spacing =
      info.shortcut.empty() ? 0.0f : style.ItemSpacing.y;
  const float available_icon_height = card_size.y - padding_y * 2.0f -
                                      line_height - footer_height -
                                      footer_spacing;
  const float min_icon_radius = line_height * 0.9f;
  float max_icon_radius = card_size.y * 0.24f;
  max_icon_radius = std::max(max_icon_radius, min_icon_radius);
  const float icon_radius = std::clamp(available_icon_height * 0.5f,
                                       min_icon_radius, max_icon_radius);
 
  const ImVec2 cursor_pos = ImGui::GetCursorScreenPos();
  ImDrawList* draw_list = ImGui::GetWindowDrawList();
  const ImVec2 icon_center(cursor_pos.x + card_size.x * 0.5f,
                           cursor_pos.y + padding_y + icon_radius);
  float title_y = icon_center.y + icon_radius + style.ItemSpacing.y;
  const float footer_y = cursor_pos.y + card_size.y - padding_y - footer_height;
  if (title_y + line_height > footer_y - style.ItemSpacing.y) {
    title_y = footer_y - line_height - style.ItemSpacing.y;
  }
 
  bool is_recent = std::find(recent_editors_.begin(), recent_editors_.end(),
                             info.type) != recent_editors_.end();
 
  // Create gradient background
  ImU32 color_top =
      ImGui::GetColorU32(ScaleColor(base_color, 0.4f, 0.85f * disabled_alpha));
  ImU32 color_bottom =
      ImGui::GetColorU32(ScaleColor(base_color, 0.2f, 0.9f * disabled_alpha));
 
  // Draw gradient card background
  draw_list->AddRectFilledMultiColor(
      cursor_pos,
      ImVec2(cursor_pos.x + card_size.x, cursor_pos.y + card_size.y), color_top,
      color_top, color_bottom, color_bottom);
 
  // Colored border
  ImU32 border_color =
      is_recent
          ? ImGui::GetColorU32(WithAlpha(base_color, 1.0f * disabled_alpha))
          : ImGui::GetColorU32(
                ScaleColor(base_color, 0.6f, 0.7f * disabled_alpha));
  const float rounding = std::max(style.FrameRounding, card_size.y * 0.05f);
  const float border_thickness =
      is_recent ? std::max(2.0f, style.FrameBorderSize + 1.0f)
                : std::max(1.0f, style.FrameBorderSize);
  draw_list->AddRect(
      cursor_pos,
      ImVec2(cursor_pos.x + card_size.x, cursor_pos.y + card_size.y),
      border_color, rounding, 0, border_thickness);
 
  // Recent indicator badge
  if (is_recent) {
    const float badge_radius =
        std::clamp(line_height * 0.6f, line_height * 0.4f, line_height);
    ImVec2 badge_pos(cursor_pos.x + card_size.x - padding_x - badge_radius,
                     cursor_pos.y + padding_y + badge_radius);
    draw_list->AddCircleFilled(badge_pos, badge_radius,
                               ImGui::GetColorU32(base_color), 16);
    const ImU32 star_color = ImGui::GetColorU32(text_primary);
    const ImVec2 star_size =
        text_font->CalcTextSizeA(text_font_size, FLT_MAX, 0.0f, ICON_MD_STAR);
    const ImVec2 star_pos(badge_pos.x - star_size.x * 0.5f,
                          badge_pos.y - star_size.y * 0.5f);
    draw_list->AddText(text_font, text_font_size, star_pos, star_color,
                       ICON_MD_STAR);
  }
 
  // Make button transparent (we draw our own background)
  ImVec4 button_bg = ImGui::GetStyleColorVec4(ImGuiCol_Button);
  button_bg.w = 0.0f;
  gui::StyleColorGuard card_btn_guard(
      {{ImGuiCol_Button, button_bg},
       {ImGuiCol_ButtonHovered,
        ScaleColor(base_color, 0.3f, enabled ? 0.5f : 0.2f)},
       {ImGuiCol_ButtonActive,
        ScaleColor(base_color, 0.5f, enabled ? 0.7f : 0.2f)}});
 
  if (!enabled) {
    ImGui::BeginDisabled();
  }
  bool clicked =
      ImGui::Button(absl::StrCat("##", info.name).c_str(), card_size);
  if (!enabled) {
    ImGui::EndDisabled();
  }
  bool is_hovered = ImGui::IsItemHovered();
 
  // Draw icon with colored background circle
  ImU32 icon_bg =
      ImGui::GetColorU32(WithAlpha(base_color, 1.0f * disabled_alpha));
  draw_list->AddCircleFilled(icon_center, icon_radius, icon_bg, 32);
 
  // Draw icon
  ImFont* icon_font = ImGui::GetFont();
  if (ImGui::GetIO().Fonts->Fonts.size() > 2 &&
      card_size.y >= kDashboardCardBaseHeight) {
    icon_font = ImGui::GetIO().Fonts->Fonts[2];
  } else if (ImGui::GetIO().Fonts->Fonts.size() > 1) {
    icon_font = ImGui::GetIO().Fonts->Fonts[1];
  }
  ImGui::PushFont(icon_font);
  const float icon_font_size = ImGui::GetFontSize();
  const ImVec2 icon_size = icon_font->CalcTextSizeA(icon_font_size, FLT_MAX,
                                                    0.0f, info.icon.c_str());
  ImGui::PopFont();
  const ImVec2 icon_text_pos(icon_center.x - icon_size.x * 0.5f,
                             icon_center.y - icon_size.y * 0.5f);
  draw_list->AddText(icon_font, icon_font_size, icon_text_pos,
                     ImGui::GetColorU32(text_primary), info.icon.c_str());
 
  // Draw name
  const ImVec2 name_size = text_font->CalcTextSizeA(text_font_size, FLT_MAX,
                                                    0.0f, info.name.c_str());
  float name_x = cursor_pos.x + (card_size.x - name_size.x) * 0.5f;
  const float name_min_x = cursor_pos.x + padding_x;
  const float name_max_x = cursor_pos.x + card_size.x - padding_x;
  name_x = std::clamp(name_x, name_min_x, name_max_x);
  const ImVec2 name_pos(name_x, title_y);
  const ImVec4 name_clip(name_min_x, cursor_pos.y + padding_y, name_max_x,
                         footer_y);
  draw_list->AddText(text_font, text_font_size, name_pos,
                     ImGui::GetColorU32(WithAlpha(base_color, disabled_alpha)),
                     info.name.c_str(), nullptr, 0.0f, &name_clip);
 
  // Draw shortcut hint if available
  if (!info.shortcut.empty()) {
    const ImVec2 shortcut_pos(cursor_pos.x + padding_x, footer_y);
    const ImVec4 shortcut_clip(cursor_pos.x + padding_x, footer_y,
                               cursor_pos.x + card_size.x - padding_x,
                               cursor_pos.y + card_size.y - padding_y);
    draw_list->AddText(text_font, text_font_size, shortcut_pos,
                       ImGui::GetColorU32(text_secondary),
                       info.shortcut.c_str(), nullptr, 0.0f, &shortcut_clip);
  }
 
  // Hover glow effect
  if (is_hovered) {
    ImU32 glow_color = ImGui::GetColorU32(
        ScaleColor(base_color, 1.0f, enabled ? 0.18f : 0.08f));
    draw_list->AddRectFilled(
        cursor_pos,
        ImVec2(cursor_pos.x + card_size.x, cursor_pos.y + card_size.y),
        glow_color, rounding);
  }
 
  // Enhanced tooltip
  if (is_hovered) {
    const float tooltip_width = std::clamp(card_size.x * 1.4f, 240.0f, 340.0f);
    ImGui::SetNextWindowSize(ImVec2(tooltip_width, 0), ImGuiCond_Always);
    ImGui::BeginTooltip();
    ImGui::PushFont(nullptr, HeadingFontSize(1.15f));
    ImGui::TextColored(WithAlpha(base_color, disabled_alpha), "%s %s",
                       info.icon.c_str(), info.name.c_str());
    ImGui::PopFont();
    ImGui::Separator();
    ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + tooltip_width - 20.0f);
    if (!enabled) {
      ImGui::TextWrapped(tr("Load a ROM to open this editor."));
    } else {
      ImGui::TextWrapped("%s", info.description.c_str());
    }
    ImGui::PopTextWrapPos();
    if (enabled && !info.shortcut.empty()) {
      ImGui::Spacing();
      ImGui::TextColored(WithAlpha(base_color, disabled_alpha),
                         ICON_MD_KEYBOARD " %s", info.shortcut.c_str());
    }
    if (is_recent) {
      ImGui::Spacing();
      ImGui::TextColored(accent, ICON_MD_STAR " Recently used");
    }
    ImGui::EndTooltip();
  }
 
  if (clicked && enabled) {
    if (editor_switcher_) {
      MarkRecentlyUsed(info.type);
      editor_switcher_->SwitchToEditor(info.type);
      editor_switcher_->DismissEditorSelection();
      show_ = false;
    }
  }
 
  ImGui::PopID();
}
 
void DashboardPanel::MarkRecentlyUsed(EditorType type) {
  // Remove if already in list
  auto it = std::find(recent_editors_.begin(), recent_editors_.end(), type);
  if (it != recent_editors_.end()) {
    recent_editors_.erase(it);
  }
 
  // Add to front
  recent_editors_.insert(recent_editors_.begin(), type);
 
  // Limit size
  if (recent_editors_.size() > kMaxRecentEditors) {
    recent_editors_.resize(kMaxRecentEditors);
  }
 
  SaveRecentEditors();
}
 
std::vector<EditorType> DashboardPanel::ParseRecentEditors(
    const std::string& data, size_t max_entries) {
  std::vector<EditorType> parsed;
  std::istringstream ss(data);
  std::string line;
  while (std::getline(ss, line) && parsed.size() < max_entries) {
    // Per line, so one malformed entry drops that line instead of abandoning
    // every entry after it. The previous single try/catch around the whole
    // loop turned one bad line into a truncated list.
    int type_int = 0;
    try {
      type_int = std::stoi(line);
    } catch (const std::exception&) {
      continue;
    }
    // kUnknown is the sentinel, not an editor: the old lower bound of `>= 0`
    // admitted it, and a kUnknown recent would arm the layout-protection path
    // that ApplyDockTree keys on. The old upper bound of `< kSettings` also
    // excluded kSettings itself, which is a real editor.
    if (type_int <= static_cast<int>(EditorType::kUnknown) ||
        type_int > static_cast<int>(EditorType::kSettings)) {
      continue;
    }
    const auto type = static_cast<EditorType>(type_int);
    // Recents are a set; a duplicated line must not consume two slots.
    if (std::find(parsed.begin(), parsed.end(), type) != parsed.end()) {
      continue;
    }
    parsed.push_back(type);
  }
  return parsed;
}
 
void DashboardPanel::LoadRecentEditors() {
  // Assign, don't append: LoadRecentEditors is called on construction and
  // again on demand, and appending duplicated the whole list.
  recent_editors_ = ParseRecentEditors(
      util::LoadFileFromConfigDir("recent_editors.txt"), kMaxRecentEditors);
}
 
void DashboardPanel::SaveRecentEditors() {
  try {
    std::ostringstream ss;
    for (EditorType type : recent_editors_) {
      ss << static_cast<int>(type) << "\n";
    }
    util::SaveFile("recent_editors.txt", ss.str());
  } catch (...) {
    // Ignore save errors
  }
}
 
void DashboardPanel::ClearRecentEditors() {
  recent_editors_.clear();
  SaveRecentEditors();
}
 
}  // namespace editor
}  // namespace yaze