palette_group_panel.cc

Go to the documentation of this file.

#define IMGUI_DEFINE_MATH_OPERATORS
#include "palette_group_panel.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <cctype>
#include <chrono>
#include <string>
#include <vector>
 
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_split.h"
#include "absl/strings/strip.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/system/session/hack_manifest_save_validation.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gui/automation/widget_auto_register.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/widgets/themed_widgets.h"
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
#include "util/json.h"
 
namespace yaze {
namespace editor {
 
using namespace yaze::gui;
using gui::DangerButton;
using gui::PrimaryButton;
using gui::SectionHeader;
using gui::ThemedButton;
using gui::ThemedIconButton;
 
namespace {
 
absl::StatusOr<uint16_t> ParseSnesHexToken(std::string token) {
  token = std::string(absl::StripAsciiWhitespace(token));
  if (token.empty()) {
    return absl::InvalidArgumentError("Empty color token");
  }
 
  if (token[0] == '$') {
    token.erase(0, 1);
  } else if (token.size() > 2 &&
             (token.rfind("0x", 0) == 0 || token.rfind("0X", 0) == 0)) {
    token.erase(0, 2);
  }
 
  if (token.empty()) {
    return absl::InvalidArgumentError("Color token is missing hex digits");
  }
 
  for (char ch : token) {
    if (!std::isxdigit(static_cast<unsigned char>(ch))) {
      return absl::InvalidArgumentError(
          absl::StrCat("Invalid hex digit in color token: ", token));
    }
  }
 
  if (token.size() > 4) {
    return absl::InvalidArgumentError(
        absl::StrCat("Color token is too long for SNES color: ", token));
  }
 
  uint32_t value = 0;
  try {
    value = static_cast<uint32_t>(std::stoul(token, nullptr, 16));
  } catch (const std::exception&) {
    return absl::InvalidArgumentError(
        absl::StrCat("Failed to parse color token: ", token));
  }
 
  if (value > 0x7FFF) {
    return absl::InvalidArgumentError(
        absl::StrCat("SNES color out of range (0x0000-0x7FFF): ", token));
  }
 
  return static_cast<uint16_t>(value);
}
 
absl::StatusOr<std::vector<uint16_t>> ParseClipboardColors(
    const std::string& clipboard) {
  std::vector<uint16_t> colors;
  for (const auto& raw_token : absl::StrSplit(
           clipboard, absl::ByAnyChar(", \n\r\t"), absl::SkipEmpty())) {
    const std::string token =
        std::string(absl::StripAsciiWhitespace(raw_token));
    if (token.empty()) {
      continue;
    }
    auto color_or = ParseSnesHexToken(token);
    if (!color_or.ok()) {
      return color_or.status();
    }
    colors.push_back(*color_or);
  }
 
  if (colors.empty()) {
    return absl::InvalidArgumentError("No colors found in clipboard data");
  }
 
  return colors;
}
 
#if defined(YAZE_WITH_JSON)
absl::StatusOr<uint16_t> ParseSnesColorJson(const yaze::Json& value) {
  if (value.is_string()) {
    return ParseSnesHexToken(value.get<std::string>());
  }
  if (value.is_number_integer()) {
    int parsed = value.get<int>();
    if (parsed < 0 || parsed > 0x7FFF) {
      return absl::InvalidArgumentError(
          absl::StrFormat("SNES color out of range: %d", parsed));
    }
    return static_cast<uint16_t>(parsed);
  }
  if (value.is_number_unsigned()) {
    uint32_t parsed = value.get<uint32_t>();
    if (parsed > 0x7FFF) {
      return absl::InvalidArgumentError(
          absl::StrFormat("SNES color out of range: %u", parsed));
    }
    return static_cast<uint16_t>(parsed);
  }
  return absl::InvalidArgumentError(
      "Invalid color value type (expected string or number)");
}
#endif
 
}  // namespace
 
PaletteGroupPanel::PaletteGroupPanel(const std::string& group_name,
                                     const std::string& display_name, Rom* rom,
                                     zelda3::GameData* game_data)
    : group_name_(group_name),
      display_name_(display_name),
      rom_(rom),
      game_data_(game_data) {
  // Note: We can't call GetPaletteGroup() here because it's a pure virtual
  // function and the derived class isn't fully constructed yet. Original
  // palettes will be loaded on first Draw() call instead.
}
 
void PaletteGroupPanel::Draw(bool* p_open) {
  DrawContent(false);
}
 
void PaletteGroupPanel::DrawEmbedded() {
  DrawContent(true);
}
 
void PaletteGroupPanel::SetSelectedPaletteIndex(int index) {
  const auto* group = GetPaletteGroup();
  selected_palette_ =
      group && group->size() > 0
          ? std::clamp(index, 0, static_cast<int>(group->size()) - 1)
          : 0;
  selected_color_ = -1;
}
 
void PaletteGroupPanel::DrawContent(bool embedded) {
  if (!IsManagedSession() || !rom_ || !rom_->is_loaded())
    return;
  if (!embedded)
    DrawToolbar();
  DrawPaletteSelector();
  bool batch_requested = false;
  if (embedded) {
    ImGui::SameLine();
    if (ThemedIconButton(ICON_MD_MORE_HORIZ, "Selected palette tools"))
      ImGui::OpenPopup("SelectedPaletteTools");
    if (ImGui::BeginPopup("SelectedPaletteTools")) {
      if (ImGui::MenuItem(tr("Copy colors")))
        ExportToClipboard();
      if (ImGui::MenuItem(tr("Paste colors"))) {
        auto result = ImportFromClipboard();
        if (!result.ok() && toast_manager_)
          toast_manager_->Show(std::string(result.message()),
                               ToastType::kError);
      }
      if (ImGui::MenuItem(tr("Batch operations...")))
        batch_requested = true;
      ImGui::EndPopup();
    }
  }
  ImGui::Separator();
  const bool columns =
      ImGui::GetContentRegionAvail().x >= ImGui::GetFontSize() * 44;
  const auto draw_grid = [this]() {
    DrawPaletteGrid();
    ImGui::Spacing();
    if (ImGui::CollapsingHeader(tr("Details"))) {
      DrawMetadataInfo();
      DrawCustomPanels();
    }
  };
  const auto draw_picker = [this]() {
    if (selected_color_ >= 0) {
      DrawColorPicker();
      if (ImGui::CollapsingHeader(tr("Color values")))
        DrawColorInfo();
    } else {
      ImGui::TextDisabled(tr("Select a color to edit"));
    }
  };
  if (columns &&
      ImGui::BeginTable("PaletteContent", 2, ImGuiTableFlags_Resizable)) {
    ImGui::TableSetupColumn("Colors", ImGuiTableColumnFlags_WidthStretch, 0.6f);
    ImGui::TableSetupColumn("Edit", ImGuiTableColumnFlags_WidthStretch, 0.4f);
    ImGui::TableNextColumn();
    draw_grid();
    ImGui::TableNextColumn();
    draw_picker();
    ImGui::EndTable();
  } else if (!columns) {
    draw_grid();
    ImGui::Spacing();
    draw_picker();
  }
  if (batch_requested)
    ImGui::OpenPopup("BatchOperations");
  DrawBatchOperationsPopup();
}
 
void PaletteGroupPanel::DrawPaletteGrid() {
  auto* palette = GetMutablePalette(selected_palette_);
  if (!palette)
    return;
  const int columns = GetColorsPerRow();
  const float spacing = ImGui::GetStyle().ItemSpacing.x;
  const float cell = std::clamp(
      (ImGui::GetContentRegionAvail().x - (columns - 1) * spacing) / columns,
      12.0f, ImGui::GetFrameHeight() * 1.35f);
  for (int i = 0; i < palette->size(); ++i) {
    ImGui::PushID(i);
    if (gui::PaletteColorButton("##color", (*palette)[i], i == selected_color_,
                                IsColorModified(selected_palette_, i),
                                ImVec2(cell, cell)))
      selected_color_ = i;
    gui::AutoRegisterLastItem("button", absl::StrFormat("Palette color %d", i));
    ImGui::PopID();
    if ((i + 1) % columns && i + 1 < palette->size())
      ImGui::SameLine();
  }
}
 
void PaletteGroupPanel::DrawToolbar() {
  // Query PaletteManager for group-specific modification status
  bool has_changes = gfx::PaletteManager::Get().IsGroupModified(group_name_);
 
  // Save button (primary action)
  ImGui::BeginDisabled(!has_changes);
  if (PrimaryButton(
          absl::StrFormat("%s Apply to buffer", ICON_MD_SAVE).c_str())) {
    auto status = SaveToRom();
    if (!status.ok()) {
      if (toast_manager_) {
        toast_manager_->Show(absl::StrFormat("Failed to save %s: %s",
                                             display_name_, status.message()),
                             ToastType::kError);
      }
    }
  }
  ImGui::EndDisabled();
  if (!has_changes &&
      ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(tr("No palette changes to apply"));
  }
 
  ImGui::SameLine();
 
  // Discard button (danger action)
  ImGui::BeginDisabled(!has_changes);
  if (DangerButton(absl::StrFormat("%s Discard", ICON_MD_UNDO).c_str())) {
    DiscardChanges();
  }
  ImGui::EndDisabled();
  if (!has_changes &&
      ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(tr("No palette changes to discard"));
  }
 
  ImGui::SameLine();
 
  // Modified indicator badge (show modified color count for this group)
  if (has_changes) {
    size_t modified_count = 0;
    auto* group = GetPaletteGroup();
    if (group) {
      for (int p = 0; p < group->size(); p++) {
        if (gfx::PaletteManager::Get().IsPaletteModified(group_name_, p)) {
          modified_count++;
        }
      }
    }
    ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f), tr("%s %zu modified"),
                       ICON_MD_EDIT, modified_count);
  }
 
  ImGui::SameLine();
  ImGui::Dummy(ImVec2(20, 0));  // Spacer
  ImGui::SameLine();
 
  // Undo/Redo (global operations via PaletteManager)
  bool can_undo = gfx::PaletteManager::Get().CanUndo();
  ImGui::BeginDisabled(!can_undo);
  if (ThemedIconButton(ICON_MD_UNDO, "Undo")) {
    Undo();
  }
  ImGui::EndDisabled();
  if (!can_undo && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(tr("Nothing to undo"));
  }
 
  ImGui::SameLine();
  bool can_redo = gfx::PaletteManager::Get().CanRedo();
  ImGui::BeginDisabled(!can_redo);
  if (ThemedIconButton(ICON_MD_REDO, "Redo")) {
    Redo();
  }
  ImGui::EndDisabled();
  if (!can_redo && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(tr("Nothing to redo"));
  }
 
  ImGui::SameLine();
  ImGui::Dummy(ImVec2(20, 0));  // Spacer
  ImGui::SameLine();
 
  // Export/Import
  if (ThemedIconButton(ICON_MD_FILE_DOWNLOAD, "Export to clipboard")) {
    ExportToClipboard();
  }
 
  ImGui::SameLine();
  if (ThemedIconButton(ICON_MD_FILE_UPLOAD, "Import from clipboard")) {
    ImportFromClipboard();
  }
 
  ImGui::SameLine();
  if (ThemedIconButton(ICON_MD_MORE_VERT, "Batch operations")) {
    ImGui::OpenPopup("BatchOperations");
  }
 
  // Custom toolbar buttons from derived classes
  DrawCustomToolbarButtons();
}
 
void PaletteGroupPanel::DrawPaletteSelector() {
  auto* palette_group = GetPaletteGroup();
  if (!palette_group)
    return;
 
  int num_palettes = palette_group->size();
 
  ImGui::Text(tr("Palette:"));
  ImGui::SameLine();
 
  ImGui::SetNextItemWidth(LayoutHelpers::GetStandardInputWidth());
  if (ImGui::BeginCombo(
          "##PaletteSelect",
          absl::StrFormat("Palette %d", selected_palette_).c_str())) {
    const float item_height = ImGui::GetTextLineHeightWithSpacing();
    ImGuiListClipper clipper;
    clipper.Begin(num_palettes, item_height);
    if (selected_palette_ >= 0 && selected_palette_ < num_palettes) {
      clipper.IncludeItemByIndex(selected_palette_);
    }
 
    while (clipper.Step()) {
      for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; ++i) {
        bool is_selected = (selected_palette_ == i);
        bool is_modified = IsPaletteModified(i);
 
        std::string label = absl::StrFormat("Palette %d", i);
        if (is_modified) {
          label += " *";
        }
 
        if (ImGui::Selectable(label.c_str(), is_selected)) {
          selected_palette_ = i;
          selected_color_ = -1;  // Reset color selection
        }
        if (is_selected) {
          ImGui::SetItemDefaultFocus();
        }
      }
    }
    ImGui::EndCombo();
  }
 
  // Show reset button for current palette
  ImGui::SameLine();
  ImGui::BeginDisabled(!IsPaletteModified(selected_palette_));
  if (ThemedIconButton(ICON_MD_RESTORE, "Reset palette to original")) {
    ResetPalette(selected_palette_);
  }
  ImGui::EndDisabled();
}
 
void PaletteGroupPanel::DrawColorPicker() {
  if (selected_color_ < 0)
    return;
 
  auto* palette = GetMutablePalette(selected_palette_);
  if (!palette)
    return;
 
  SectionHeader("Color Editor");
 
  if (selected_color_ >= palette->size())
    return;
  auto original = GetOriginalColor(selected_palette_, selected_color_);
 
  auto& manager = gfx::PaletteManager::Get();
  const ImGuiID picker_id = ImGui::GetID("##picker");
  if (active_picker_ == picker_id &&
      ImGui::IsKeyPressed(ImGuiKey_Escape, false)) {
    manager.CancelColorEdit(picker_id);
    picker_cancelled_ = true;
  }
 
  // Read current model state so Undo/Redo and comparison windows stay in sync.
  ImGui::SetNextItemWidth(
      std::min(ImGui::GetContentRegionAvail().x, ImGui::GetFontSize() * 19));
  ImVec4 col = ConvertSnesColorToImVec4((*palette)[selected_color_]);
  ImGui::BeginDisabled(picker_cancelled_ && active_picker_ == picker_id);
  const bool changed = ImGui::ColorPicker4(
      "##picker", &col.x,
      ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_PickerHueWheel |
          ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV);
  const bool active = ImGui::IsItemActive();
  // ColorPicker is a group with ID zero while idle; register its actual bounds
  // with our stable ID so automation can discover it before starting a drag.
  gui::WidgetIdRegistry::WidgetMetadata picker_metadata;
  picker_metadata.label = "Palette color picker";
  picker_metadata.window_name = ImGui::GetCurrentWindow()->Name;
  picker_metadata.visible = ImGui::IsItemVisible();
  picker_metadata.enabled = !picker_cancelled_;
  const auto min = ImGui::GetItemRectMin();
  const auto max = ImGui::GetItemRectMax();
  picker_metadata.bounds = {min.x, min.y, max.x, max.y, true};
  gui::WidgetIdRegistry::Instance().RegisterWidget(
      absl::StrCat("Palette/picker:", picker_id), "color", picker_id,
      "Drag to preview; release commits one Undo step; Escape cancels",
      picker_metadata);
  ImGui::EndDisabled();
  if (!picker_cancelled_) {
    if (active &&
        (active_picker_ != picker_id || !manager.HasColorEdit(picker_id))) {
      const auto status = manager.BeginColorEdit(group_name_, selected_palette_,
                                                 selected_color_, picker_id);
      if (status.ok()) {
        active_picker_ = picker_id;
      }
    }
    if (changed) {
      SetColor(selected_palette_, selected_color_,
               ConvertImVec4ToSnesColor(col));
    }
    if (!active && active_picker_ == picker_id) {
      manager.CommitColorEdit(picker_id);
      active_picker_ = 0;
    }
  } else if (active_picker_ == picker_id && !ImGui::IsMouseDown(0)) {
    // Keep a held mouse from starting another edit immediately after Escape.
    picker_cancelled_ = false;
    active_picker_ = 0;
  }
  col = ConvertSnesColorToImVec4((*palette)[selected_color_]);
 
  char snes[5];
  absl::SNPrintF(snes, sizeof(snes), "%04X",
                 (*palette)[selected_color_].snes());
  ImGui::SetNextItemWidth(ImGui::GetFontSize() * 7);
  if (ImGui::InputText("SNES", snes, sizeof(snes),
                       ImGuiInputTextFlags_CharsHexadecimal |
                           ImGuiInputTextFlags_EnterReturnsTrue)) {
    const auto parsed = ParseSnesHexToken(snes);
    if (parsed.ok()) {
      SetColor(selected_palette_, selected_color_, gfx::SnesColor(*parsed));
    } else if (toast_manager_) {
      toast_manager_->Show(std::string(parsed.status().message()),
                           ToastType::kError);
    }
  }
  gui::AutoRegisterLastItem("input", "SNES color");
 
  // Current vs Original comparison
  ImGui::Separator();
  ImGui::Text(tr("Current vs Original"));
 
  ImGui::ColorButton("##current", col,
                     ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
                     ImVec2(60, 40));
 
  gui::AutoRegisterLastItem("color", "Current palette color");
 
  ImGui::SameLine();
 
  ImVec4 orig_col = ConvertSnesColorToImVec4(original);
  if (ImGui::ColorButton(
          "##original", orig_col,
          ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
          ImVec2(60, 40))) {
    // Click to restore original
    SetColor(selected_palette_, selected_color_, original);
  }
 
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Click to restore original color"));
  }
 
  gui::AutoRegisterLastItem("button", "Restore original palette color");
 
  // Reset button
  ImGui::BeginDisabled(!IsColorModified(selected_palette_, selected_color_));
  if (ThemedButton(absl::StrFormat("%s Reset", ICON_MD_RESTORE).c_str(),
                   ImVec2(-1, 0))) {
    ResetColor(selected_palette_, selected_color_);
  }
  ImGui::EndDisabled();
}
 
void PaletteGroupPanel::DrawColorInfo() {
  if (selected_color_ < 0)
    return;
 
  SectionHeader("Color Information");
 
  const auto* palette = GetMutablePalette(selected_palette_);
  if (!palette || selected_color_ >= palette->size())
    return;
  const auto color = (*palette)[selected_color_];
  auto col = color.rgb();
  int r = static_cast<int>(col.x);
  int g = static_cast<int>(col.y);
  int b = static_cast<int>(col.z);
 
  // RGB values
  ImGui::Text(tr("RGB (0-255): (%d, %d, %d)"), r, g, b);
  if (ImGui::IsItemClicked()) {
    ImGui::SetClipboardText(absl::StrFormat("(%d, %d, %d)", r, g, b).c_str());
  }
 
  // SNES BGR555 value
  if (show_snes_format_) {
    ImGui::Text(tr("SNES BGR555: $%04X"), color.snes());
    if (ImGui::IsItemClicked()) {
      ImGui::SetClipboardText(absl::StrFormat("$%04X", color.snes()).c_str());
    }
  }
 
  // Hex value
  if (show_hex_format_) {
    ImGui::Text(tr("Hex: #%02X%02X%02X"), r, g, b);
    if (ImGui::IsItemClicked()) {
      ImGui::SetClipboardText(
          absl::StrFormat("#%02X%02X%02X", r, g, b).c_str());
    }
  }
 
  ImGui::TextDisabled(tr("Click any value to copy"));
}
 
void PaletteGroupPanel::DrawMetadataInfo() {
  const auto& metadata = GetMetadata();
  if (selected_palette_ >= metadata.palettes.size())
    return;
 
  const auto& pal_meta = metadata.palettes[selected_palette_];
 
  SectionHeader("Palette Metadata");
 
  // Palette ID
  ImGui::Text(tr("Palette ID: %d"), pal_meta.palette_id);
 
  // Name
  if (!pal_meta.name.empty()) {
    ImGui::Text(tr("Name: %s"), pal_meta.name.c_str());
  }
 
  // Description
  if (!pal_meta.description.empty()) {
    ImGui::TextWrapped("%s", pal_meta.description.c_str());
  }
 
  ImGui::Separator();
 
  // Palette dimensions and color depth
  ImGui::Text(tr("Dimensions: %d colors (%dx%d)"), metadata.colors_per_palette,
              metadata.colors_per_row,
              (metadata.colors_per_palette + metadata.colors_per_row - 1) /
                  metadata.colors_per_row);
 
  ImGui::Text(tr("Color Depth: %d BPP (4-bit SNES)"), 4);
  ImGui::TextDisabled(tr("(16 colors per palette possible)"));
 
  ImGui::Separator();
 
  // ROM Address
  ImGui::Text(tr("ROM Address: $%06X"), pal_meta.rom_address);
  if (ImGui::IsItemClicked()) {
    ImGui::SetClipboardText(
        absl::StrFormat("$%06X", pal_meta.rom_address).c_str());
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Click to copy address"));
  }
 
  // VRAM Address (if applicable)
  if (pal_meta.vram_address > 0) {
    ImGui::Text(tr("VRAM Address: $%04X"), pal_meta.vram_address);
    if (ImGui::IsItemClicked()) {
      ImGui::SetClipboardText(
          absl::StrFormat("$%04X", pal_meta.vram_address).c_str());
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Click to copy VRAM address"));
    }
  }
 
  // Usage notes
  if (!pal_meta.usage_notes.empty()) {
    ImGui::Separator();
    ImGui::TextDisabled(tr("Usage Notes:"));
    ImGui::TextWrapped("%s", pal_meta.usage_notes.c_str());
  }
}
 
void PaletteGroupPanel::DrawBatchOperationsPopup() {
  if (ImGui::BeginPopup("BatchOperations")) {
    SectionHeader("Batch Operations");
 
    if (ThemedButton("Copy Current Palette", ImVec2(-1, 0))) {
      ExportToClipboard();
      ImGui::CloseCurrentPopup();
    }
 
    if (ThemedButton("Paste to Current Palette", ImVec2(-1, 0))) {
      ImportFromClipboard();
      ImGui::CloseCurrentPopup();
    }
 
    ImGui::Separator();
 
    if (ThemedButton("Reset All Palettes", ImVec2(-1, 0))) {
      DiscardChanges();
      ImGui::CloseCurrentPopup();
    }
 
    ImGui::EndPopup();
  }
}
 
// ========== Palette Operations ==========
 
void PaletteGroupPanel::SetColor(int palette_index, int color_index,
                                 const gfx::SnesColor& new_color) {
  if (!IsManagedSession()) {
    if (toast_manager_) {
      toast_manager_->Show("Cannot edit palettes from an inactive ROM session",
                           ToastType::kError);
    }
    return;
  }
 
  // Delegate to PaletteManager for centralized tracking and undo/redo
  auto status = gfx::PaletteManager::Get().SetColor(group_name_, palette_index,
                                                    color_index, new_color);
  if (!status.ok()) {
    if (toast_manager_) {
      toast_manager_->Show(
          absl::StrFormat("Failed to set color: %s", status.message()),
          ToastType::kError);
    }
    return;
  }
}
 
absl::Status PaletteGroupPanel::SaveToRom() {
  if (!IsManagedSession()) {
    return absl::FailedPreconditionError(
        "Cannot save palettes from an inactive ROM session");
  }
  auto& palette_manager = gfx::PaletteManager::Get();
  if (project_ != nullptr && project_->hack_manifest.loaded()) {
    const auto ranges =
        palette_manager.GetModifiedGroupColorWriteRanges(group_name_);
    if (!ranges.empty()) {
      const absl::Status preflight = ValidateHackManifestSaveConflicts(
          project_->hack_manifest, project_->rom_metadata.write_policy, ranges,
          display_name_, "PaletteGroupPanel", toast_manager_);
      if (!preflight.ok()) {
        return preflight;
      }
    }
  }
 
  // Delegate to PaletteManager for centralized save operation.
  return palette_manager.SaveGroup(group_name_);
}
 
void PaletteGroupPanel::DiscardChanges() {
  if (!IsManagedSession()) {
    return;
  }
  // Delegate to PaletteManager for centralized discard operation
  gfx::PaletteManager::Get().DiscardGroup(group_name_);
 
  // Reset selection
  selected_color_ = -1;
}
 
void PaletteGroupPanel::ResetPalette(int palette_index) {
  if (!IsManagedSession()) {
    return;
  }
  // Delegate to PaletteManager for centralized reset operation
  gfx::PaletteManager::Get().ResetPalette(group_name_, palette_index);
}
 
void PaletteGroupPanel::ResetColor(int palette_index, int color_index) {
  if (!IsManagedSession()) {
    return;
  }
  // Delegate to PaletteManager for centralized reset operation
  gfx::PaletteManager::Get().ResetColor(group_name_, palette_index,
                                        color_index);
}
 
// ========== History Management ==========
 
void PaletteGroupPanel::Undo() {
  if (!IsManagedSession()) {
    return;
  }
  // Delegate to PaletteManager's global undo system
  gfx::PaletteManager::Get().Undo();
}
 
void PaletteGroupPanel::Redo() {
  if (!IsManagedSession()) {
    return;
  }
  // Delegate to PaletteManager's global redo system
  gfx::PaletteManager::Get().Redo();
}
 
void PaletteGroupPanel::ClearHistory() {
  if (!IsManagedSession()) {
    return;
  }
  // Delegate to PaletteManager's global history
  gfx::PaletteManager::Get().ClearHistory();
}
 
// ========== State Queries ==========
 
bool PaletteGroupPanel::IsPaletteModified(int palette_index) const {
  if (!IsManagedSession()) {
    return false;
  }
  // Query PaletteManager for modification status
  return gfx::PaletteManager::Get().IsPaletteModified(group_name_,
                                                      palette_index);
}
 
bool PaletteGroupPanel::IsColorModified(int palette_index,
                                        int color_index) const {
  if (!IsManagedSession()) {
    return false;
  }
  // Query PaletteManager for modification status
  return gfx::PaletteManager::Get().IsColorModified(group_name_, palette_index,
                                                    color_index);
}
 
bool PaletteGroupPanel::HasUnsavedChanges() const {
  if (!IsManagedSession()) {
    return false;
  }
  // Query PaletteManager for group-specific modification status
  return gfx::PaletteManager::Get().IsGroupModified(group_name_);
}
 
bool PaletteGroupPanel::CanUndo() const {
  if (!IsManagedSession()) {
    return false;
  }
  // Query PaletteManager for global undo availability
  return gfx::PaletteManager::Get().CanUndo();
}
 
bool PaletteGroupPanel::CanRedo() const {
  if (!IsManagedSession()) {
    return false;
  }
  // Query PaletteManager for global redo availability
  return gfx::PaletteManager::Get().CanRedo();
}
 
// ========== Helper Methods ==========
 
gfx::SnesPalette* PaletteGroupPanel::GetMutablePalette(int index) {
  auto* palette_group = GetPaletteGroup();
  if (!palette_group || index < 0 || index >= palette_group->size()) {
    return nullptr;
  }
  return palette_group->mutable_palette(index);
}
 
gfx::SnesColor PaletteGroupPanel::GetOriginalColor(int palette_index,
                                                   int color_index) const {
  // Get original color from PaletteManager's snapshots
  return gfx::PaletteManager::Get().GetOriginalColor(group_name_, palette_index,
                                                     color_index);
}
 
bool PaletteGroupPanel::IsManagedSession() const {
  return game_data_ != nullptr &&
         gfx::PaletteManager::Get().IsManaging(game_data_);
}
 
// MarkModified and ClearModified removed - PaletteManager handles tracking now
 
// ========== Export/Import ==========
 
std::string PaletteGroupPanel::ExportToJson() const {
#if defined(YAZE_WITH_JSON)
  auto* palette_group = GetPaletteGroup();
  if (!palette_group) {
    return "{}";
  }
 
  yaze::Json root = yaze::Json::object();
  root["version"] = 1;
  root["group"] = group_name_;
  root["display_name"] = display_name_;
  root["palettes"] = yaze::Json::array();
 
  for (size_t palette_index = 0; palette_index < palette_group->size();
       palette_index++) {
    const auto& palette =
        palette_group->palette_ref(static_cast<int>(palette_index));
    yaze::Json palette_json = yaze::Json::object();
    palette_json["index"] = static_cast<int>(palette_index);
    palette_json["colors"] = yaze::Json::array();
 
    for (size_t color_index = 0; color_index < palette.size(); color_index++) {
      palette_json["colors"].push_back(
          absl::StrFormat("$%04X", palette[color_index].snes()));
    }
 
    root["palettes"].push_back(palette_json);
  }
 
  return root.dump(2);
#else
  return "{}";
#endif
}
 
absl::Status PaletteGroupPanel::ImportFromJson(const std::string& json) {
  if (!IsManagedSession()) {
    return absl::FailedPreconditionError(
        "Cannot import palettes into an inactive ROM session");
  }
#if !defined(YAZE_WITH_JSON)
  return absl::UnimplementedError("JSON support is disabled");
#else
  auto* palette_group = GetPaletteGroup();
  if (!palette_group) {
    return absl::FailedPreconditionError("Palette group is unavailable");
  }
 
  yaze::Json root;
  try {
    root = yaze::Json::parse(json);
  } catch (const std::exception& e) {
    return absl::InvalidArgumentError(
        absl::StrCat("Failed to parse palette JSON: ", e.what()));
  }
 
  if (!root.is_object()) {
    return absl::InvalidArgumentError("Palette JSON must be an object");
  }
 
  if (root.contains("version")) {
    const auto& version_value = root["version"];
    if (!version_value.is_number_integer() &&
        !version_value.is_number_unsigned()) {
      return absl::InvalidArgumentError(
          "Palette JSON 'version' must be an integer");
    }
    int version = version_value.get<int>();
    if (version != 1) {
      return absl::InvalidArgumentError(
          absl::StrFormat("Unsupported palette JSON version: %d", version));
    }
  }
 
  if (root.contains("group")) {
    const auto& group_value = root["group"];
    if (!group_value.is_string()) {
      return absl::InvalidArgumentError(
          "Palette JSON 'group' must be a string");
    }
    const std::string group = group_value.get<std::string>();
    if (group != group_name_) {
      return absl::InvalidArgumentError(absl::StrFormat(
          "Palette JSON group '%s' does not match '%s'", group, group_name_));
    }
  }
 
  if (!root.contains("palettes") || !root["palettes"].is_array()) {
    return absl::InvalidArgumentError(
        "Palette JSON must contain a 'palettes' array");
  }
 
  struct PaletteImport {
    int index;
    std::vector<uint16_t> colors;
  };
 
  std::vector<PaletteImport> imports;
  for (const auto& palette_json : root["palettes"]) {
    if (!palette_json.is_object()) {
      return absl::InvalidArgumentError("Palette entry must be a JSON object");
    }
 
    if (!palette_json.contains("index") ||
        !palette_json["index"].is_number_integer()) {
      return absl::InvalidArgumentError(
          "Palette entry is missing integer 'index'");
    }
 
    int palette_index = palette_json["index"].get<int>();
    if (palette_index < 0 || palette_index >= palette_group->size()) {
      return absl::InvalidArgumentError(absl::StrFormat(
          "Palette index %d out of range [0, %d)", palette_index,
          static_cast<int>(palette_group->size())));
    }
 
    if (!palette_json.contains("colors") ||
        !palette_json["colors"].is_array()) {
      return absl::InvalidArgumentError(
          "Palette entry is missing 'colors' array");
    }
 
    std::vector<uint16_t> colors;
    colors.reserve(palette_json["colors"].size());
    for (const auto& color_json : palette_json["colors"]) {
      auto color_or = ParseSnesColorJson(color_json);
      if (!color_or.ok()) {
        return color_or.status();
      }
      colors.push_back(*color_or);
    }
 
    const auto& palette = palette_group->palette_ref(palette_index);
    if (colors.size() != palette.size()) {
      return absl::InvalidArgumentError(absl::StrFormat(
          "Palette %d expects %d colors but received %d", palette_index,
          static_cast<int>(palette.size()), static_cast<int>(colors.size())));
    }
 
    imports.push_back({palette_index, std::move(colors)});
  }
 
  auto& manager = gfx::PaletteManager::Get();
  manager.BeginBatch();
  for (const auto& import : imports) {
    for (size_t color_index = 0; color_index < import.colors.size();
         color_index++) {
      auto status = manager.SetColor(
          group_name_, import.index, static_cast<int>(color_index),
          gfx::SnesColor(import.colors[color_index]));
      if (!status.ok()) {
        manager.EndBatch();
        return status;
      }
    }
  }
  manager.EndBatch();
 
  return absl::OkStatus();
#endif
}
 
std::string PaletteGroupPanel::ExportToClipboard() const {
  auto* palette_group = GetPaletteGroup();
  if (!palette_group || selected_palette_ >= palette_group->size()) {
    return "";
  }
 
  auto palette = palette_group->palette(selected_palette_);
  std::string result;
 
  for (size_t i = 0; i < palette.size(); i++) {
    result += absl::StrFormat("$%04X", palette[i].snes());
    if (i < palette.size() - 1) {
      result += ",";
    }
  }
 
  ImGui::SetClipboardText(result.c_str());
  return result;
}
 
absl::Status PaletteGroupPanel::ImportFromClipboard() {
  if (!IsManagedSession()) {
    return absl::FailedPreconditionError(
        "Cannot import palettes into an inactive ROM session");
  }
  auto* palette = GetMutablePalette(selected_palette_);
  if (!palette) {
    return absl::FailedPreconditionError("No palette selected");
  }
 
  const char* clipboard = ImGui::GetClipboardText();
  if (!clipboard || clipboard[0] == '\0') {
    return absl::InvalidArgumentError("Clipboard is empty");
  }
 
  auto colors_or = ParseClipboardColors(clipboard);
  if (!colors_or.ok()) {
    return colors_or.status();
  }
 
  const auto& colors = *colors_or;
  if (colors.size() != palette->size()) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Clipboard contains %d colors but palette expects %d",
        static_cast<int>(colors.size()), static_cast<int>(palette->size())));
  }
 
  auto& manager = gfx::PaletteManager::Get();
  manager.BeginBatch();
  for (size_t color_index = 0; color_index < colors.size(); color_index++) {
    auto status = manager.SetColor(group_name_, selected_palette_,
                                   static_cast<int>(color_index),
                                   gfx::SnesColor(colors[color_index]));
    if (!status.ok()) {
      manager.EndBatch();
      return status;
    }
  }
  manager.EndBatch();
 
  return absl::OkStatus();
}
 
// ============================================================================
// Concrete Palette Panel Implementations
// ============================================================================
 
// ========== Overworld Main Palette Panel ==========
 
const PaletteGroupMetadata OverworldMainPalettePanel::metadata_ =
    OverworldMainPalettePanel::InitializeMetadata();
 
OverworldMainPalettePanel::OverworldMainPalettePanel(
    Rom* rom, zelda3::GameData* game_data)
    : PaletteGroupPanel("ow_main", "Overworld Main Palettes", rom, game_data) {}
 
PaletteGroupMetadata OverworldMainPalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "ow_main";
  metadata.display_name = "Overworld Main Palettes";
  metadata.colors_per_palette = 35;
  metadata.colors_per_row = 7;
 
  // ALTTP OW main palettes are 35 colors per set (5 sub-palettes x 7 colors),
  // stored contiguously in ROM and loaded into CGRAM starting at $0042.
  // See usdasm: bank_1B.asm -> PaletteLoad_OWBGMain / PaletteData_owmain_00.
  for (int i = 0; i < 6; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = absl::StrFormat("Overworld Main %02d", i);
    pal.description =
        "BG main palette set (35 colors = 5x7, transparent slots are implicit)";
    pal.rom_address = gfx::kOverworldPaletteMain + (i * (35 * 2));
    pal.vram_address = 0;
    pal.usage_notes =
        "Loaded by PaletteLoad_OWBGMain to CGRAM $0042 (rows 2-6, cols 1-7).";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* OverworldMainPalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("ow_main");
}
 
const gfx::PaletteGroup* OverworldMainPalettePanel::GetPaletteGroup() const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("ow_main");
}
 
// ========== Overworld Animated Palette Panel ==========
 
const PaletteGroupMetadata OverworldAnimatedPalettePanel::metadata_ =
    OverworldAnimatedPalettePanel::InitializeMetadata();
 
OverworldAnimatedPalettePanel::OverworldAnimatedPalettePanel(
    Rom* rom, zelda3::GameData* game_data)
    : PaletteGroupPanel("ow_animated", "Overworld Animated Palettes", rom,
                        game_data) {}
 
PaletteGroupMetadata OverworldAnimatedPalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "ow_animated";
  metadata.display_name = "Overworld Animated Palettes";
  metadata.colors_per_palette = 7;
  metadata.colors_per_row = 7;
 
  // ALTTP OW animated palettes are 7 colors each, stored at kOverworldPaletteAnimated.
  // See usdasm: bank_1B.asm -> PaletteLoad_OWBG3 / PaletteData_owanim_00.
  for (int i = 0; i < 14; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = absl::StrFormat("OW Anim %02d", i);
    pal.description =
        "Animated overlay palette (7 colors, transparent slot is implicit)";
    pal.rom_address = gfx::kOverworldPaletteAnimated + (i * (7 * 2));
    pal.vram_address = 0;
    pal.usage_notes =
        "Loaded by PaletteLoad_OWBG3 to CGRAM $00E2 (row 7, cols 1-7).";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* OverworldAnimatedPalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("ow_animated");
}
 
const gfx::PaletteGroup* OverworldAnimatedPalettePanel::GetPaletteGroup()
    const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("ow_animated");
}
 
// ========== Dungeon Main Palette Panel ==========
 
const PaletteGroupMetadata DungeonMainPalettePanel::metadata_ =
    DungeonMainPalettePanel::InitializeMetadata();
 
DungeonMainPalettePanel::DungeonMainPalettePanel(Rom* rom,
                                                 zelda3::GameData* game_data)
    : PaletteGroupPanel("dungeon_main", "Dungeon Main Palettes", rom,
                        game_data) {}
 
PaletteGroupMetadata DungeonMainPalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "dungeon_main";
  metadata.display_name = "Dungeon Main Palettes";
  metadata.colors_per_palette = 90;
  metadata.colors_per_row = 15;
 
  // Dungeon palettes (0-19)
  const char* dungeon_names[] = {
      "Sewers",          "Hyrule Castle", "Eastern Palace",     "Desert Palace",
      "Agahnim's Tower", "Swamp Palace",  "Palace of Darkness", "Misery Mire",
      "Skull Woods",     "Ice Palace",    "Tower of Hera",      "Thieves' Town",
      "Turtle Rock",     "Ganon's Tower", "Generic 1",          "Generic 2",
      "Generic 3",       "Generic 4",     "Generic 5",          "Generic 6"};
 
  for (int i = 0; i < 20; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = dungeon_names[i];
    pal.description = absl::StrFormat("Dungeon palette %d", i);
    pal.rom_address = gfx::kDungeonMainPalettes + (i * (90 * 2));
    pal.vram_address = 0;
    pal.usage_notes =
        "90 colors = 6 CGRAM banks x 15 colors (transparent slot per bank is "
        "implicit).";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* DungeonMainPalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("dungeon_main");
}
 
const gfx::PaletteGroup* DungeonMainPalettePanel::GetPaletteGroup() const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("dungeon_main");
}
 
// ========== Sprite Palette Panel ==========
 
const PaletteGroupMetadata SpritePalettePanel::metadata_ =
    SpritePalettePanel::InitializeMetadata();
 
SpritePalettePanel::SpritePalettePanel(Rom* rom, zelda3::GameData* game_data)
    : PaletteGroupPanel("global_sprites", "Sprite Palettes", rom, game_data) {}
 
PaletteGroupMetadata SpritePalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "global_sprites";
  metadata.display_name = "Global Sprite Palettes";
  metadata.colors_per_palette =
      60;  // 4 sprite banks x 15 colors (transparent is implicit)
  metadata.colors_per_row = 15;  // Display as 4 rows of 15 to match ROM layout
 
  // 2 palette sets: Light World and Dark World
  const char* sprite_names[] = {"Global Sprites (Light World)",
                                "Global Sprites (Dark World)"};
 
  for (int i = 0; i < 2; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = sprite_names[i];
    pal.description =
        "60 colors = 4 sprite banks x 15 colors (transparent slots are "
        "implicit)";
    pal.rom_address =
        (i == 0) ? gfx::kGlobalSpritesLW : gfx::kGlobalSpritePalettesDW;
    pal.vram_address = 0;  // Palettes reside in PPU CGRAM (not VRAM)
    pal.usage_notes =
        "Loaded into CGRAM rows 9-12, cols 1-15 (row col0 is transparent).";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* SpritePalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("global_sprites");
}
 
const gfx::PaletteGroup* SpritePalettePanel::GetPaletteGroup() const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("global_sprites");
}
 
void SpritePalettePanel::DrawCustomPanels() {
  SectionHeader("CGRAM Placement");
  ImGui::TextWrapped(
      tr("Global sprite palettes are stored in ROM as 4 banks of 15 colors "
         "(transparent is implicit) and loaded to PPU CGRAM rows 9-12, cols "
         "1-15."));
  ImGui::TextDisabled(tr("Note: Palettes live in CGRAM, not VRAM."));
}
 
// ========== Equipment Palette Panel ==========
 
const PaletteGroupMetadata EquipmentPalettePanel::metadata_ =
    EquipmentPalettePanel::InitializeMetadata();
 
EquipmentPalettePanel::EquipmentPalettePanel(Rom* rom,
                                             zelda3::GameData* game_data)
    : PaletteGroupPanel("armors", "Equipment Palettes", rom, game_data) {}
 
PaletteGroupMetadata EquipmentPalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "armors";
  metadata.display_name = "Equipment Palettes";
  metadata.colors_per_palette = 15;
  metadata.colors_per_row = 15;
 
  const char* armor_names[] = {"Green Mail", "Blue Mail", "Red Mail", "Bunny",
                               "Electrocuted"};
 
  for (int i = 0; i < 5; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = armor_names[i];
    pal.description = absl::StrFormat("Link appearance: %s", armor_names[i]);
    pal.rom_address = gfx::kArmorPalettes + (i * (15 * 2));
    pal.vram_address = 0;
    pal.usage_notes =
        "15 colors per set (transparent slot is implicit when loaded into "
        "CGRAM).";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* EquipmentPalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("armors");
}
 
const gfx::PaletteGroup* EquipmentPalettePanel::GetPaletteGroup() const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("armors");
}
 
// ========== Sprites Aux1 Palette Panel ==========
 
const PaletteGroupMetadata SpritesAux1PalettePanel::metadata_ =
    SpritesAux1PalettePanel::InitializeMetadata();
 
SpritesAux1PalettePanel::SpritesAux1PalettePanel(Rom* rom,
                                                 zelda3::GameData* game_data)
    : PaletteGroupPanel("sprites_aux1", "Sprites Aux 1", rom, game_data) {}
 
PaletteGroupMetadata SpritesAux1PalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "sprites_aux1";
  metadata.display_name = "Sprites Aux 1";
  metadata.colors_per_palette = 7;
  metadata.colors_per_row = 7;
 
  for (int i = 0; i < 12; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = absl::StrFormat("Sprites Aux1 %02d", i);
    pal.description =
        "Auxiliary sprite palette (7 colors, transparent is implicit)";
    pal.rom_address = 0xDD39E + (i * 14);  // 7 colors * 2 bytes
    pal.vram_address = 0;
    pal.usage_notes =
        "Loaded into CGRAM with an implicit transparent slot at index 0 of the "
        "bank.";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* SpritesAux1PalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("sprites_aux1");
}
 
const gfx::PaletteGroup* SpritesAux1PalettePanel::GetPaletteGroup() const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("sprites_aux1");
}
 
// ========== Sprites Aux2 Palette Panel ==========
 
const PaletteGroupMetadata SpritesAux2PalettePanel::metadata_ =
    SpritesAux2PalettePanel::InitializeMetadata();
 
SpritesAux2PalettePanel::SpritesAux2PalettePanel(Rom* rom,
                                                 zelda3::GameData* game_data)
    : PaletteGroupPanel("sprites_aux2", "Sprites Aux 2", rom, game_data) {}
 
PaletteGroupMetadata SpritesAux2PalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "sprites_aux2";
  metadata.display_name = "Sprites Aux 2";
  metadata.colors_per_palette = 7;
  metadata.colors_per_row = 7;
 
  for (int i = 0; i < 11; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = absl::StrFormat("Sprites Aux2 %02d", i);
    pal.description =
        "Auxiliary sprite palette (7 colors, transparent is implicit)";
    pal.rom_address = 0xDD446 + (i * 14);  // 7 colors * 2 bytes
    pal.vram_address = 0;
    pal.usage_notes =
        "Loaded into CGRAM with an implicit transparent slot at index 0 of the "
        "bank.";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* SpritesAux2PalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("sprites_aux2");
}
 
const gfx::PaletteGroup* SpritesAux2PalettePanel::GetPaletteGroup() const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("sprites_aux2");
}
 
// ========== Sprites Aux3 Palette Panel ==========
 
const PaletteGroupMetadata SpritesAux3PalettePanel::metadata_ =
    SpritesAux3PalettePanel::InitializeMetadata();
 
SpritesAux3PalettePanel::SpritesAux3PalettePanel(Rom* rom,
                                                 zelda3::GameData* game_data)
    : PaletteGroupPanel("sprites_aux3", "Sprites Aux 3", rom, game_data) {}
 
PaletteGroupMetadata SpritesAux3PalettePanel::InitializeMetadata() {
  PaletteGroupMetadata metadata;
  metadata.group_name = "sprites_aux3";
  metadata.display_name = "Sprites Aux 3";
  metadata.colors_per_palette = 7;
  metadata.colors_per_row = 7;
 
  for (int i = 0; i < 24; i++) {
    PaletteMetadata pal;
    pal.palette_id = i;
    pal.name = absl::StrFormat("Sprites Aux3 %02d", i);
    pal.description =
        "Auxiliary sprite palette (7 colors, transparent is implicit)";
    pal.rom_address = 0xDD4E0 + (i * 14);  // 7 colors * 2 bytes
    pal.vram_address = 0;
    pal.usage_notes =
        "Loaded into CGRAM with an implicit transparent slot at index 0 of the "
        "bank.";
    metadata.palettes.push_back(pal);
  }
 
  return metadata;
}
 
gfx::PaletteGroup* SpritesAux3PalettePanel::GetPaletteGroup() {
  if (!game_data_)
    return nullptr;
  return game_data_->palette_groups.get_group("sprites_aux3");
}
 
const gfx::PaletteGroup* SpritesAux3PalettePanel::GetPaletteGroup() const {
  if (!game_data_)
    return nullptr;
  return const_cast<zelda3::GameData*>(game_data_)
      ->palette_groups.get_group("sprites_aux3");
}
 
}  // namespace editor
}  // namespace yaze