canvas_context_menu.cc

Go to the documentation of this file.

#include "canvas_context_menu.h"
#include "util/i18n/tr.h"
 
#include "app/gfx/debug/performance/performance_dashboard.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/widgets/palette_editor_widget.h"
#include "app/platform/sdl_compat.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
namespace {
inline void Dispatch(const std::function<void(CanvasContextMenu::Command,
                                              const CanvasConfig&)>& handler,
                     CanvasContextMenu::Command command, CanvasConfig config) {
  if (handler) {
    handler(command, config);
  }
}
}  // namespace
 
void CanvasContextMenu::Initialize(const std::string& canvas_id) {
  canvas_id_ = canvas_id;
  enabled_ = true;
  current_usage_ = CanvasUsage::kTilePainting;
  palette_editor_ = std::make_unique<PaletteEditorWidget>();
 
  // Initialize canvas state
  canvas_size_ = ImVec2(0, 0);
  content_size_ = ImVec2(0, 0);
  global_scale_ = 1.0F;
  grid_step_ = 32.0F;
  enable_grid_ = true;
  enable_hex_labels_ = false;
  enable_custom_labels_ = false;
  enable_context_menu_ = true;
  is_draggable_ = false;
  auto_resize_ = false;
  scrolling_ = ImVec2(0, 0);
 
  // Create default menu items
  CreateDefaultMenuItems();
}
 
void CanvasContextMenu::SetUsageMode(CanvasUsage usage) {
  current_usage_ = usage;
}
 
void CanvasContextMenu::AddMenuItem(const CanvasMenuItem& item) {
  global_items_.push_back(item);
}
 
void CanvasContextMenu::AddMenuItem(const CanvasMenuItem& item,
                                    CanvasUsage usage) {
  usage_specific_items_[usage].push_back(item);
}
 
void CanvasContextMenu::ClearMenuItems() {
  global_items_.clear();
  usage_specific_items_.clear();
}
 
void CanvasContextMenu::Render(
    const std::string& context_id, const ImVec2& /* mouse_pos */, Rom* rom,
    const gfx::Bitmap* bitmap, const gfx::SnesPalette* /* palette */,
    const std::function<void(Command, const CanvasConfig&)>& command_handler,
    CanvasConfig current_config, Canvas* canvas) {
  if (!enabled_)
    return;
 
  // Context menu (under default mouse threshold)
  if (ImVec2 drag_delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Right);
      enable_context_menu_ && drag_delta.x == 0.0F && drag_delta.y == 0.0F) {
    ImGui::OpenPopupOnItemClick(context_id.c_str(),
                                ImGuiPopupFlags_MouseButtonRight);
  }
 
  // Phase 4: Popup callback for automatic popup management
  auto popup_callback = [canvas](const std::string& id,
                                 std::function<void()> callback) {
    if (canvas) {
      canvas->GetPopupRegistry().Open(id, callback);
    }
  };
 
  // Contents of the Context Menu (Phase 4: Priority-based ordering)
  if (ImGui::BeginPopup(context_id.c_str())) {
    // PRIORITY 0: Editor-specific items (from Canvas::editor_menu_)
    if (canvas && !canvas->editor_menu().sections.empty()) {
      RenderCanvasMenu(canvas->editor_menu(), popup_callback);
    }
 
    // Only show built-in menu items if show_builtin_context_menu is true
    if (current_config.show_builtin_context_menu) {
      // Also render usage-specific items (legacy support)
      if (!usage_specific_items_[current_usage_].empty()) {
        RenderUsageSpecificMenu(popup_callback);
        ImGui::Separator();
      }
 
      // Shared built-in canvas tools. Bitmap and palette mutation entries
      // ("Pixel Format", "Edit Palette") would corrupt the underlying data
      // for read-only roles (kPreviewOnly, kSelectionSource) whose bitmap
      // is a shared view (gfx-group sheets, sprite atlas thumbnails). Gate
      // them on the canvas role; view controls below stay unconditional so
      // read-only canvases keep pan/zoom/reset.
      if (bitmap && RoleAllowsBitmapMutation(current_config.role)) {
        RenderBitmapOperationsMenu(const_cast<gfx::Bitmap*>(bitmap));
        ImGui::Separator();
 
        RenderPaletteOperationsMenu(rom, const_cast<gfx::Bitmap*>(bitmap));
        ImGui::Separator();
      }
 
      RenderViewControlsMenu(command_handler, current_config);
 
      // PRIORITY 30: Debug/Performance
      if (ImGui::GetIO().KeyCtrl) {  // Only show when Ctrl is held
        ImGui::Separator();
        RenderPerformanceMenu();
      }
 
      // Render global menu items (if any)
      if (!global_items_.empty()) {
        ImGui::Separator();
        RenderMenuSection("Custom Actions", global_items_, popup_callback);
      }
    }
 
    ImGui::EndPopup();
  }
}
 
bool CanvasContextMenu::ShouldShowContextMenu() const {
  return enabled_ && enable_context_menu_;
}
 
void CanvasContextMenu::SetCanvasState(
    const ImVec2& canvas_size, const ImVec2& content_size, float global_scale,
    float grid_step, bool enable_grid, bool enable_hex_labels,
    bool enable_custom_labels, bool enable_context_menu, bool is_draggable,
    bool auto_resize, const ImVec2& scrolling) {
  canvas_size_ = canvas_size;
  content_size_ = content_size;
  global_scale_ = global_scale;
  grid_step_ = grid_step;
  enable_grid_ = enable_grid;
  enable_hex_labels_ = enable_hex_labels;
  enable_custom_labels_ = enable_custom_labels;
  enable_context_menu_ = enable_context_menu;
  is_draggable_ = is_draggable;
  auto_resize_ = auto_resize;
  scrolling_ = scrolling;
}
 
void CanvasContextMenu::RenderMenuItem(
    const CanvasMenuItem& item,
    std::function<void(const std::string&, std::function<void()>)>
        popup_callback) {
  // Phase 4: Delegate to canvas_menu.h implementation
  gui::RenderMenuItem(item, popup_callback);
}
 
void CanvasContextMenu::RenderMenuSection(
    const std::string& title, const std::vector<CanvasMenuItem>& items,
    std::function<void(const std::string&, std::function<void()>)>
        popup_callback) {
  if (items.empty())
    return;
 
  ImGui::TextColored(ImVec4(0.7F, 0.7F, 0.7F, 1.0F), "%s", title.c_str());
  for (const auto& item : items) {
    RenderMenuItem(item, popup_callback);
  }
}
 
void CanvasContextMenu::RenderUsageSpecificMenu(
    std::function<void(const std::string&, std::function<void()>)>
        popup_callback) {
  auto it = usage_specific_items_.find(current_usage_);
  if (it == usage_specific_items_.end() || it->second.empty()) {
    return;
  }
 
  std::string usage_name = GetUsageModeName(current_usage_);
  ImVec4 usage_color = GetUsageModeColor(current_usage_);
 
  ImGui::TextColored(usage_color, tr("%s %s Mode"), ICON_MD_COLOR_LENS,
                     usage_name.c_str());
  ImGui::Separator();
 
  for (const auto& item : it->second) {
    RenderMenuItem(item, popup_callback);
  }
}
 
void CanvasContextMenu::RenderViewControlsMenu(
    const std::function<void(Command, const CanvasConfig&)>& command_handler,
    CanvasConfig current_config) {
  if (ImGui::BeginMenu(ICON_MD_VISIBILITY " View Controls")) {
    if (ImGui::MenuItem(tr("Reset View"), "Ctrl+R")) {
      Dispatch(command_handler, Command::kResetView, current_config);
    }
    if (ImGui::MenuItem(tr("Zoom to Fit"), "Ctrl+F")) {
      Dispatch(command_handler, Command::kZoomToFit, current_config);
    }
    if (ImGui::BeginMenu(ICON_MD_ZOOM_IN " Zoom")) {
      if (ImGui::MenuItem(tr("Zoom In"), "Ctrl++")) {
        CanvasConfig updated = current_config;
        updated.global_scale *= 1.25F;
        Dispatch(command_handler, Command::kSetScale, updated);
      }
      if (ImGui::MenuItem(tr("Zoom Out"), "Ctrl+-")) {
        CanvasConfig updated = current_config;
        updated.global_scale *= 0.8F;
        Dispatch(command_handler, Command::kSetScale, updated);
      }
 
      const struct ScaleOption {
        const char* label;
        float value;
      } scale_options[] = {{"0.25x", 0.25F}, {"0.5x", 0.5F}, {"1x", 1.0F},
                           {"2x", 2.0F},     {"4x", 4.0F},   {"8x", 8.0F}};
 
      ImGui::Separator();
      for (const auto& option : scale_options) {
        const bool selected = current_config.global_scale == option.value;
        if (ImGui::MenuItem(option.label, nullptr, selected)) {
          CanvasConfig updated = current_config;
          updated.global_scale = option.value;
          Dispatch(command_handler, Command::kSetScale, updated);
        }
      }
      ImGui::EndMenu();
    }
 
    ImGui::Separator();
    if (ImGui::MenuItem(tr("Show Grid"), nullptr, enable_grid_)) {
      CanvasConfig updated = current_config;
      updated.enable_grid = !enable_grid_;
      Dispatch(command_handler, Command::kToggleGrid, updated);
    }
    if (ImGui::MenuItem(tr("Show Hex Labels"), nullptr, enable_hex_labels_)) {
      CanvasConfig updated = current_config;
      updated.enable_hex_labels = !enable_hex_labels_;
      Dispatch(command_handler, Command::kToggleHexLabels, updated);
    }
    if (ImGui::MenuItem(tr("Show Custom Labels"), nullptr,
                        enable_custom_labels_)) {
      CanvasConfig updated = current_config;
      updated.enable_custom_labels = !enable_custom_labels_;
      Dispatch(command_handler, Command::kToggleCustomLabels, updated);
    }
 
    if (ImGui::BeginMenu(ICON_MD_GRID_ON " Grid")) {
      const struct GridOption {
        const char* label;
        float value;
      } grid_options[] = {
          {"8x8", 8.0F}, {"16x16", 16.0F}, {"32x32", 32.0F}, {"64x64", 64.0F}};
 
      for (const auto& option : grid_options) {
        const bool selected = grid_step_ == option.value;
        if (ImGui::MenuItem(option.label, nullptr, selected)) {
          CanvasConfig updated = current_config;
          updated.grid_step = option.value;
          Dispatch(command_handler, Command::kSetGridStep, updated);
        }
      }
      ImGui::EndMenu();
    }
 
    ImGui::Separator();
    ImGui::TextDisabled(tr("Canvas %.0f x %.0f"), canvas_size_.x,
                        canvas_size_.y);
    ImGui::TextDisabled(tr("Content %.0f x %.0f"), content_size_.x,
                        content_size_.y);
    ImGui::TextDisabled(tr("Scale %.2f"), global_scale_);
    ImGui::TextDisabled(tr("Grid %.1f"), grid_step_);
 
    ImGui::Separator();
    if (ImGui::MenuItem(tr("Advanced Properties..."))) {
      CanvasConfig updated = current_config;
      updated.enable_grid = enable_grid_;
      updated.enable_hex_labels = enable_hex_labels_;
      updated.enable_custom_labels = enable_custom_labels_;
      updated.enable_context_menu = enable_context_menu_;
      updated.is_draggable = is_draggable_;
      updated.auto_resize = auto_resize_;
      updated.grid_step = grid_step_;
      updated.canvas_size = canvas_size_;
      updated.content_size = content_size_;
      updated.scrolling = scrolling_;
      Dispatch(command_handler, Command::kOpenAdvancedProperties, updated);
    }
    ImGui::EndMenu();
  }
}
 
void CanvasContextMenu::RenderBitmapOperationsMenu(gfx::Bitmap* bitmap) {
  if (!bitmap)
    return;
 
  if (ImGui::BeginMenu(ICON_MD_IMAGE " Bitmap")) {
    ImGui::TextDisabled(tr("Size %d x %d"), bitmap->width(), bitmap->height());
    if (auto* surface = bitmap->surface()) {
      ImGui::TextDisabled(tr("Pitch %d"), surface->pitch);
      ImGui::TextDisabled(tr("BPP %d / %d bytes"),
                          platform::GetSurfaceBitsPerPixel(surface),
                          platform::GetSurfaceBytesPerPixel(surface));
    }
 
    if (ImGui::BeginMenu(tr("Pixel Format"))) {
      if (ImGui::MenuItem(tr("Indexed"))) {
        bitmap->Reformat(gfx::BitmapFormat::kIndexed);
        // Queue texture update via Arena's deferred system
        gfx::Arena::Get().QueueTextureCommand(
            gfx::Arena::TextureCommandType::UPDATE, bitmap);
      }
      if (ImGui::MenuItem(tr("4BPP"))) {
        bitmap->Reformat(gfx::BitmapFormat::k4bpp);
        // Queue texture update via Arena's deferred system
        gfx::Arena::Get().QueueTextureCommand(
            gfx::Arena::TextureCommandType::UPDATE, bitmap);
      }
      if (ImGui::MenuItem(tr("8BPP"))) {
        bitmap->Reformat(gfx::BitmapFormat::k8bpp);
        // Queue texture update via Arena's deferred system
        gfx::Arena::Get().QueueTextureCommand(
            gfx::Arena::TextureCommandType::UPDATE, bitmap);
      }
      ImGui::EndMenu();
    }
 
    if (ImGui::BeginMenu(tr("Format Tools"))) {
      if (ImGui::MenuItem(tr("Format Analysis..."))) {
        // Open BPP analysis
      }
      if (ImGui::MenuItem(tr("Convert Format..."))) {
        // Open BPP conversion dialog
      }
      if (ImGui::MenuItem(tr("Format Comparison..."))) {
        // Open format comparison tool
      }
      ImGui::EndMenu();
    }
 
    ImGui::EndMenu();
  }
}
 
void CanvasContextMenu::RenderPaletteOperationsMenu(Rom* rom,
                                                    gfx::Bitmap* bitmap) {
  if (!bitmap)
    return;
 
  if (ImGui::BeginMenu(ICON_MD_PALETTE " Palette")) {
    if (ImGui::MenuItem(tr("Edit Palette..."))) {
      palette_editor_->ShowPaletteEditor(*bitmap->mutable_palette(),
                                         "Palette Editor");
    }
    if (ImGui::MenuItem(tr("Color Analysis..."))) {
      palette_editor_->ShowColorAnalysis(*bitmap, "Color Analysis");
    }
 
    if (rom && ImGui::BeginMenu(tr("ROM Palette Selection"))) {
      palette_editor_->Initialize(rom);
 
      // Render palette selector inline
      ImGui::Text(tr("Group:"));
      ImGui::SameLine();
      ImGui::InputScalar("##group", ImGuiDataType_U64,
                         &edit_palette_group_name_index_);
      ImGui::Text(tr("Palette:"));
      ImGui::SameLine();
      ImGui::InputScalar("##palette", ImGuiDataType_U64, &edit_palette_index_);
 
      if (ImGui::Button(tr("Apply to Canvas"))) {
        palette_editor_->ApplyROMPalette(bitmap, edit_palette_group_name_index_,
                                         edit_palette_index_);
      }
      ImGui::EndMenu();
    }
 
    if (ImGui::BeginMenu(tr("View Palette"))) {
      DisplayEditablePalette(*bitmap->mutable_palette(), "Palette", true, 8);
      ImGui::EndMenu();
    }
 
    ImGui::Separator();
 
    // Palette Help submenu
    if (ImGui::BeginMenu(ICON_MD_HELP " Palette Help")) {
      ImGui::TextColored(ImVec4(0.7F, 0.9F, 1.0F, 1.0F), tr("Bitmap Metadata"));
      ImGui::Separator();
 
      const auto& meta = bitmap->metadata();
      ImGui::Text(tr("Source BPP: %d"), meta.source_bpp);
      ImGui::Text(tr("Palette Format: %s"),
                  meta.palette_format == 0 ? "Full" : "Sub-palette");
      ImGui::Text(tr("Source Type: %s"), meta.source_type.c_str());
      ImGui::Text(tr("Expected Colors: %d"), meta.palette_colors);
      ImGui::Text(tr("Actual Palette Size: %zu"), bitmap->palette().size());
 
      ImGui::Separator();
      ImGui::TextColored(ImVec4(1.0F, 0.9F, 0.6F, 1.0F),
                         tr("Palette Application Method"));
      if (meta.palette_format == 0) {
        ImGui::TextWrapped(
            tr("Full palette (SetPalette) - all colors applied directly"));
      } else {
        ImGui::TextWrapped(tr(
            "Sub-palette (SetPaletteWithTransparent) - color 0 is transparent, "
            "1-7 from palette"));
      }
 
      ImGui::Separator();
      ImGui::TextColored(ImVec4(0.6F, 1.0F, 0.6F, 1.0F), tr("Documentation"));
      if (ImGui::MenuItem(tr("Palette System Architecture"))) {
        ImGui::SetClipboardText("yaze/docs/palette-system-architecture.md");
        // TODO: Open file in system viewer
      }
      if (ImGui::MenuItem(tr("User Palette Guide"))) {
        ImGui::SetClipboardText("yaze/docs/user-palette-guide.md");
        // TODO: Open file in system viewer
      }
 
      ImGui::EndMenu();
    }
 
    ImGui::EndMenu();
  }
}
 
void CanvasContextMenu::DrawROMPaletteSelector() {
  if (!palette_editor_)
    return;
 
  palette_editor_->DrawROMPaletteSelector();
}
 
void CanvasContextMenu::RenderPerformanceMenu() {
  if (ImGui::BeginMenu(ICON_MD_TRENDING_UP " Performance")) {
    auto& profiler = gfx::PerformanceProfiler::Get();
    auto canvas_stats = profiler.GetStats("canvas_operations");
    auto draw_stats = profiler.GetStats("canvas_draw");
 
    ImGui::Text(tr("Canvas Operations: %zu"), canvas_stats.sample_count);
    ImGui::Text(tr("Average Time: %.2f ms"), draw_stats.avg_time_us / 1000.0);
 
    if (ImGui::MenuItem(tr("Performance Dashboard..."))) {
      gfx::PerformanceDashboard::Get().SetVisible(true);
    }
    if (ImGui::MenuItem(tr("Usage Report..."))) {
      // Open usage report
    }
 
    ImGui::EndMenu();
  }
}
 
void CanvasContextMenu::RenderMaterialIcon(const std::string& icon_name,
                                           const ImVec4& color) {
  // Simple material icon rendering using Unicode symbols
  static std::unordered_map<std::string, const char*> icon_map = {
      {"grid_on", ICON_MD_GRID_ON},
      {"label", ICON_MD_LABEL},
      {"edit", ICON_MD_EDIT},
      {"menu", ICON_MD_MENU},
      {"drag_indicator", ICON_MD_DRAG_INDICATOR},
      {"fit_screen", ICON_MD_FIT_SCREEN},
      {"zoom_in", ICON_MD_ZOOM_IN},
      {"speed", ICON_MD_SPEED},
      {"timer", ICON_MD_TIMER},
      {"functions", ICON_MD_FUNCTIONS},
      {"schedule", ICON_MD_SCHEDULE},
      {"refresh", ICON_MD_REFRESH},
      {"settings", ICON_MD_SETTINGS},
      {"info", ICON_MD_INFO},
      {"view", ICON_MD_VISIBILITY},
      {"properties", ICON_MD_SETTINGS},
      {"bitmap", ICON_MD_IMAGE},
      {"palette", ICON_MD_PALETTE},
      {"bpp", ICON_MD_SWAP_HORIZ},
      {"performance", ICON_MD_TRENDING_UP},
      {"grid", ICON_MD_GRID_ON},
      {"scaling", ICON_MD_ZOOM_IN}};
 
  auto it = icon_map.find(icon_name);
  if (it != icon_map.end()) {
    ImGui::TextColored(color, "%s", it->second);
  }
}
 
std::string CanvasContextMenu::GetUsageModeName(CanvasUsage usage) const {
  switch (usage) {
    case CanvasUsage::kTilePainting:
      return "Tile Painting";
    case CanvasUsage::kTileSelecting:
      return "Tile Selecting";
    case CanvasUsage::kSelectRectangle:
      return "Rectangle Selection";
    case CanvasUsage::kColorPainting:
      return "Color Painting";
    case CanvasUsage::kBitmapEditing:
      return "Bitmap Editing";
    case CanvasUsage::kPaletteEditing:
      return "Palette Editing";
    case CanvasUsage::kBppConversion:
      return "BPP Conversion";
    case CanvasUsage::kPerformanceMode:
      return "Performance Mode";
    case CanvasUsage::kEntityManipulation:
      return "Entity Manipulation";
    case CanvasUsage::kUnknown:
      return "Unknown";
    default:
      return "Unknown";
  }
}
 
ImVec4 CanvasContextMenu::GetUsageModeColor(CanvasUsage usage) const {
  switch (usage) {
    case CanvasUsage::kTilePainting:
      return ImVec4(0.2F, 1.0F, 0.2F, 1.0F);  // Green
    case CanvasUsage::kTileSelecting:
      return ImVec4(0.2F, 0.8F, 1.0F, 1.0F);  // Blue
    case CanvasUsage::kSelectRectangle:
      return ImVec4(1.0F, 0.8F, 0.2F, 1.0F);  // Yellow
    case CanvasUsage::kColorPainting:
      return ImVec4(1.0F, 0.2F, 1.0F, 1.0F);  // Magenta
    case CanvasUsage::kBitmapEditing:
      return ImVec4(1.0F, 0.5F, 0.2F, 1.0F);  // Orange
    case CanvasUsage::kPaletteEditing:
      return ImVec4(0.8F, 0.2F, 1.0F, 1.0F);  // Purple
    case CanvasUsage::kBppConversion:
      return ImVec4(0.2F, 1.0F, 1.0F, 1.0F);  // Cyan
    case CanvasUsage::kPerformanceMode:
      return ImVec4(1.0F, 0.2F, 0.2F, 1.0F);  // Red
    case CanvasUsage::kEntityManipulation:
      return ImVec4(0.4F, 0.8F, 1.0F, 1.0F);  // Light Blue
    case CanvasUsage::kUnknown:
      return ImVec4(0.7F, 0.7F, 0.7F, 1.0F);  // Gray
    default:
      return ImVec4(0.7F, 0.7F, 0.7F, 1.0F);  // Gray
  }
}
 
void CanvasContextMenu::CreateDefaultMenuItems() {
  // The shared canvas should not invent placeholder actions like "Paint Tile"
  // or "Select Tile". Callers can inject real usage-specific items when a
  // given editor has concrete actions to expose.
}
 
}  // namespace gui
}  // namespace yaze