song_browser_view.cc

Go to the documentation of this file.

#include "app/editor/music/song_browser_view.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <cstring>
 
#include "absl/strings/str_format.h"
#include "app/gui/canvas/item_context_menu.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/ui_helpers.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace editor {
namespace music {
 
using yaze::gui::GetErrorColor;
using yaze::gui::GetSuccessColor;
using yaze::gui::GetWarningColor;
using yaze::zelda3::music::MusicBank;
 
void SongBrowserView::Draw(MusicBank& bank) {
  // Search filter
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
  ImGui::InputTextWithHint("##SongFilter", ICON_MD_SEARCH " Search songs...",
                           search_buffer_, sizeof(search_buffer_));
 
  // Update filter cache if needed
  if (std::string(search_buffer_) != last_search_buffer_ ||
      (filtered_vanilla_indices_.empty() && filtered_custom_indices_.empty())) {
    last_search_buffer_ = search_buffer_;
    RebuildFilterCache(bank);
  }
 
  // Bank Space Management Section
  if (ImGui::CollapsingHeader(ICON_MD_STORAGE " Bank Space")) {
    ImGui::Indent(8.0f);
 
    // Check for expanded music patch
    if (bank.HasExpandedMusicPatch()) {
      ImGui::TextColored(GetSuccessColor(), ICON_MD_CHECK_CIRCLE
                         " Oracle of Secrets expanded music detected");
      const auto& info = bank.GetExpandedBankInfo();
      ImGui::TextDisabled(tr("Expanded bank at $%06X, Aux at $%06X"),
                          info.main_rom_offset, info.aux_rom_offset);
      ImGui::Spacing();
    }
 
    // Display space for each bank
    static const char* bank_names[] = {"Overworld", "Dungeon", "Credits",
                                       "Expanded", "Auxiliary"};
    static const MusicBank::Bank banks[] = {
        MusicBank::Bank::Overworld, MusicBank::Bank::Dungeon,
        MusicBank::Bank::Credits, MusicBank::Bank::OverworldExpanded,
        MusicBank::Bank::Auxiliary};
 
    int num_banks = bank.HasExpandedMusicPatch() ? 5 : 3;
 
    for (int i = 0; i < num_banks; ++i) {
      auto space = bank.CalculateSpaceUsage(banks[i]);
      if (space.total_bytes == 0)
        continue;  // Skip empty/invalid banks
 
      // Progress bar color based on usage
      ImVec4 bar_color =
          space.is_critical
              ? GetErrorColor()
              : (space.is_warning ? GetWarningColor() : GetSuccessColor());
 
      ImGui::Text("%s:", bank_names[i]);
      ImGui::SameLine(100);
 
      // Progress bar
      {
        gui::StyleColorGuard bar_guard(ImGuiCol_PlotHistogram, bar_color);
        float fraction = space.usage_percent / 100.0f;
        std::string overlay =
            absl::StrFormat("%d / %d bytes (%.1f%%)", space.used_bytes,
                            space.total_bytes, space.usage_percent);
        ImGui::ProgressBar(fraction, ImVec2(-1, 0), overlay.c_str());
      }
 
      // Warning/critical messages
      if (space.is_critical) {
        ImGui::TextColored(GetErrorColor(), ICON_MD_ERROR " %s",
                           space.recommendation.c_str());
      } else if (space.is_warning) {
        ImGui::TextColored(GetWarningColor(), ICON_MD_WARNING " %s",
                           space.recommendation.c_str());
      }
    }
 
    // Overall status
    ImGui::Spacing();
    if (!bank.AllSongsFit()) {
      ImGui::TextColored(GetErrorColor(),
                         ICON_MD_ERROR " Some banks are overflowing!");
      ImGui::TextDisabled(
          tr("Songs won't fit in ROM. Remove or shorten songs."));
    } else {
      ImGui::TextColored(GetSuccessColor(),
                         ICON_MD_CHECK " All songs fit in ROM");
    }
 
    ImGui::Unindent(8.0f);
  }
 
  ImGui::Separator();
 
  // Toolbar
  if (ImGui::Button(ICON_MD_ADD " New Song")) {
    int new_idx = bank.CreateNewSong("New Song", MusicBank::Bank::Dungeon);
    if (new_idx >= 0) {
      selected_song_index_ = new_idx;
      if (on_song_selected_)
        on_song_selected_(new_idx);
      if (on_edit_)
        on_edit_();
    }
  }
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_FILE_UPLOAD " Import")) {
    // TODO: Implement SPC/MML import
  }
 
  ImGui::Separator();
 
  ImGui::BeginChild("SongList", ImVec2(0, 0), true);
 
  // Vanilla Songs Section
  if (ImGui::CollapsingHeader(ICON_MD_LIBRARY_MUSIC " Vanilla Songs",
                              ImGuiTreeNodeFlags_DefaultOpen)) {
    const float item_height = ImGui::GetTextLineHeightWithSpacing();
    ImGuiListClipper clipper;
    clipper.Begin(static_cast<int>(filtered_vanilla_indices_.size()),
                  item_height);
 
    while (clipper.Step()) {
      for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; ++row) {
        int i = filtered_vanilla_indices_[row];
        const auto* song = bank.GetSong(i);
        if (!song)
          continue;
 
        std::string display_name =
            absl::StrFormat("%02X: %s", i + 1, song->name);
 
        // Icon + label
        std::string label = absl::StrFormat(ICON_MD_MUSIC_NOTE " %s##vanilla%d",
                                            display_name, i);
        bool is_selected = (selected_song_index_ == i);
 
        // Push ID to avoid conflicts with same-named items across filter resets
        ImGui::PushID(i);
        if (ImGui::Selectable(label.c_str(), is_selected)) {
          selected_song_index_ = i;
          if (on_song_selected_) {
            on_song_selected_(selected_song_index_);
          }
        }
 
        // Double-click opens tracker
        if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(0)) {
          if (on_open_tracker_) {
            on_open_tracker_(i);
          }
        }
 
        // Context menu for vanilla songs
        gui::ItemContextMenu(nullptr, [&, i]() {
          std::vector<gui::MenuItemSpec> items;
          items.emplace_back("Open Tracker", ICON_MD_MUSIC_NOTE, [this, i]() {
            if (on_open_tracker_)
              on_open_tracker_(i);
          });
          items.emplace_back("Open Piano Roll", ICON_MD_PIANO, [this, i]() {
            if (on_open_piano_roll_)
              on_open_piano_roll_(i);
          });
          items.back().separator_after = true;
          items.emplace_back("Duplicate as Custom", ICON_MD_FILE_COPY,
                             [this, &bank, i]() {
                               bank.DuplicateSong(i);
                               if (on_edit_)
                                 on_edit_();
                               // Force cache rebuild on next frame.
                               last_search_buffer_.clear();
                             });
          items.back().separator_after = true;
          items.emplace_back("Export to ASM...", ICON_MD_FILE_DOWNLOAD,
                             [this, i]() {
                               if (on_export_asm_)
                                 on_export_asm_(i);
                             });
          return items;
        });
        ImGui::PopID();
      }
    }
  }
 
  // Custom Songs Section
  if (ImGui::CollapsingHeader(ICON_MD_EDIT " Custom Songs",
                              ImGuiTreeNodeFlags_DefaultOpen)) {
    if (filtered_custom_indices_.empty()) {
      ImGui::TextDisabled(tr("No custom songs match filter"));
      ImGui::TextDisabled(tr("Click 'New Song' or duplicate a vanilla song"));
    } else {
      const float item_height = ImGui::GetTextLineHeightWithSpacing();
      ImGuiListClipper clipper;
      clipper.Begin(static_cast<int>(filtered_custom_indices_.size()),
                    item_height);
 
      while (clipper.Step()) {
        for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; ++row) {
          int i = filtered_custom_indices_[row];
          const auto* song = bank.GetSong(i);
          if (!song)
            continue;
 
          std::string display_name =
              absl::StrFormat("%02X: %s", i + 1, song->name);
 
          // Custom song icon + label (different color)
          std::string label = absl::StrFormat(
              ICON_MD_AUDIOTRACK " %s##custom%d", display_name, i);
          bool is_selected = (selected_song_index_ == i);
 
          gui::StyleColorGuard text_guard(ImGuiCol_Text, GetSuccessColor());
          ImGui::PushID(i);
          if (ImGui::Selectable(label.c_str(), is_selected)) {
            selected_song_index_ = i;
            if (on_song_selected_) {
              on_song_selected_(selected_song_index_);
            }
          }
 
          // Double-click opens tracker
          if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(0)) {
            if (on_open_tracker_) {
              on_open_tracker_(i);
            }
          }
 
          // Context menu for custom songs (includes delete/rename)
          gui::ItemContextMenu(nullptr, [&, i]() {
            std::vector<gui::MenuItemSpec> items;
            items.emplace_back("Open Tracker", ICON_MD_MUSIC_NOTE, [this, i]() {
              if (on_open_tracker_)
                on_open_tracker_(i);
            });
            items.emplace_back("Open Piano Roll", ICON_MD_PIANO, [this, i]() {
              if (on_open_piano_roll_)
                on_open_piano_roll_(i);
            });
            items.back().separator_after = true;
            items.emplace_back("Duplicate", ICON_MD_FILE_COPY,
                               [this, &bank, i]() {
                                 bank.DuplicateSong(i);
                                 if (on_edit_)
                                   on_edit_();
                                 last_search_buffer_.clear();  // Force rebuild.
                               });
            items.emplace_back(
                "Rename...", ICON_MD_DRIVE_FILE_RENAME_OUTLINE,
                [this, &bank, i]() {
                  rename_target_index_ = i;
                  rename_popup_open_ = true;
                  const auto* rename_song = bank.GetSong(i);
                  if (rename_song) {
                    std::strncpy(rename_buffer_, rename_song->name.c_str(),
                                 sizeof(rename_buffer_) - 1);
                    rename_buffer_[sizeof(rename_buffer_) - 1] = '\0';
                  }
                });
            items.back().separator_after = true;
            items.emplace_back("Export to ASM...", ICON_MD_FILE_DOWNLOAD,
                               [this, i]() {
                                 if (on_export_asm_)
                                   on_export_asm_(i);
                               });
            items.emplace_back("Import from ASM...", ICON_MD_FILE_UPLOAD,
                               [this, i]() {
                                 if (on_import_asm_)
                                   on_import_asm_(i);
                               });
            items.back().separator_after = true;
            // Deleting a custom song has no undo; require confirmation.
            items.push_back(gui::MenuItemSpec::Destructive(
                "Delete Song...", ICON_MD_DELETE, [this, &bank, i]() {
                  (void)bank.DeleteSong(i);
                  if (selected_song_index_ == i) {
                    selected_song_index_ = -1;
                  }
                  if (on_edit_)
                    on_edit_();
                  last_search_buffer_.clear();  // Force rebuild.
                }));
            return items;
          });
          ImGui::PopID();
        }
      }
    }
  }
 
  ImGui::EndChild();
 
  // Rename popup (rendered at top level so it isn't clipped by the child)
  if (rename_popup_open_) {
    ImGui::OpenPopup("Rename Song");
    rename_popup_open_ = false;
  }
 
  if (ImGui::BeginPopupModal("Rename Song", nullptr,
                             ImGuiWindowFlags_AlwaysAutoResize)) {
    ImGui::Text(tr("Enter a new name for the song:"));
    ImGui::SetNextItemWidth(300);
 
    bool enter_pressed = ImGui::InputText("##RenameSongInput", rename_buffer_,
                                          sizeof(rename_buffer_),
                                          ImGuiInputTextFlags_EnterReturnsTrue);
 
    // Focus the input on first appearance
    if (ImGui::IsWindowAppearing()) {
      ImGui::SetKeyboardFocusHere(-1);
    }
 
    bool apply = enter_pressed || ImGui::Button(tr("OK"));
    ImGui::SameLine();
    bool cancel = ImGui::Button(tr("Cancel"));
 
    if (apply && rename_target_index_ >= 0) {
      auto* target_song = bank.GetSong(rename_target_index_);
      if (target_song && std::strlen(rename_buffer_) > 0) {
        target_song->name = rename_buffer_;
        target_song->modified = true;
        if (on_edit_)
          on_edit_();
        last_search_buffer_.clear();  // Force filter rebuild.
      }
      rename_target_index_ = -1;
      ImGui::CloseCurrentPopup();
    }
 
    if (cancel) {
      rename_target_index_ = -1;
      ImGui::CloseCurrentPopup();
    }
 
    ImGui::EndPopup();
  }
}
 
bool SongBrowserView::MatchesSearch(const std::string& name) const {
  if (search_buffer_[0] == '\0')
    return true;
 
  // Case-insensitive search
  std::string lower_name = name;
  std::string lower_search(search_buffer_);
  std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(),
                 ::tolower);
  std::transform(lower_search.begin(), lower_search.end(), lower_search.begin(),
                 ::tolower);
 
  return lower_name.find(lower_search) != std::string::npos;
}
 
void SongBrowserView::RebuildFilterCache(const MusicBank& bank) {
  filtered_vanilla_indices_.clear();
  filtered_custom_indices_.clear();
 
  for (size_t i = 0; i < bank.GetSongCount(); ++i) {
    const auto* song = bank.GetSong(static_cast<int>(i));
    if (!song)
      continue;
 
    std::string display_name = absl::StrFormat("%02X: %s", i + 1, song->name);
    if (!MatchesSearch(display_name))
      continue;
 
    if (bank.IsVanilla(static_cast<int>(i))) {
      filtered_vanilla_indices_.push_back(static_cast<int>(i));
    } else {
      filtered_custom_indices_.push_back(static_cast<int>(i));
    }
  }
}
 
}  // namespace music
}  // namespace editor
}  // namespace yaze