canvas_context_menu.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_CANVAS_CANVAS_CONTEXT_MENU_H
#define YAZE_APP_GUI_CANVAS_CANVAS_CONTEXT_MENU_H
 
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas_menu.h"
#include "app/gui/canvas/canvas_modals.h"
#include "app/gui/core/icons.h"
#include "canvas_usage_tracker.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
// Forward declarations
class PaletteEditorWidget;
class Canvas;
 
class CanvasContextMenu {
 public:
  enum class Command {
    kNone,
    kResetView,
    kZoomToFit,
    kZoomIn,
    kZoomOut,
    kToggleGrid,
    kToggleHexLabels,
    kToggleCustomLabels,
    kToggleContextMenu,
    kToggleAutoResize,
    kToggleDraggable,
    kOpenAdvancedProperties,
    kOpenScalingControls,
    kSetGridStep,
    kSetScale,
  };
 
  CanvasContextMenu() = default;
 
  // Phase 4: Use unified CanvasMenuItem from canvas_menu.h
  using CanvasMenuItem = gui::CanvasMenuItem;
 
  void Initialize(const std::string& canvas_id);
  void SetUsageMode(CanvasUsage usage);
  void AddMenuItem(const CanvasMenuItem& item);
  void AddMenuItem(const CanvasMenuItem& item, CanvasUsage usage);
  void ClearMenuItems();
 
  // Phase 4: Render with editor menu integration and priority ordering
  void 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);
 
  bool ShouldShowContextMenu() const;
  void SetEnabled(bool enabled) { enabled_ = enabled; }
  bool IsEnabled() const { return enabled_; }
  CanvasUsage GetUsageMode() const { return current_usage_; }
 
  void 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);
 
 private:
  std::string canvas_id_;
  bool enabled_ = true;
  CanvasUsage current_usage_ = CanvasUsage::kTilePainting;
 
  ImVec2 canvas_size_;
  ImVec2 content_size_;
  float global_scale_ = 1.0f;
  float grid_step_ = 32.0f;
  bool enable_grid_ = true;
  bool enable_hex_labels_ = false;
  bool enable_custom_labels_ = false;
  bool enable_context_menu_ = true;
  bool is_draggable_ = false;
  bool auto_resize_ = false;
  ImVec2 scrolling_;
 
  std::unique_ptr<PaletteEditorWidget> palette_editor_;
  uint64_t edit_palette_group_name_index_ = 0;
  uint64_t edit_palette_index_ = 0;
  uint64_t edit_palette_sub_index_ = 0;
  bool refresh_graphics_ = false;
 
  void DrawROMPaletteSelector();
 
  std::unordered_map<CanvasUsage, std::vector<CanvasMenuItem>>
      usage_specific_items_;
  std::vector<CanvasMenuItem> global_items_;
 
  void RenderMenuItem(
      const CanvasMenuItem& item,
      std::function<void(const std::string&, std::function<void()>)>
          popup_callback);
  void RenderMenuSection(
      const std::string& title, const std::vector<CanvasMenuItem>& items,
      std::function<void(const std::string&, std::function<void()>)>
          popup_callback);
  void RenderUsageSpecificMenu(
      std::function<void(const std::string&, std::function<void()>)>
          popup_callback);
  void RenderViewControlsMenu(
      const std::function<void(Command, const CanvasConfig&)>& command_handler,
      CanvasConfig current_config);
  void RenderCanvasPropertiesMenu(
      const std::function<void(Command, const CanvasConfig&)>& command_handler,
      CanvasConfig current_config);
  void RenderBitmapOperationsMenu(gfx::Bitmap* bitmap);
  void RenderPaletteOperationsMenu(Rom* rom, gfx::Bitmap* bitmap);
  void RenderBppOperationsMenu(const gfx::Bitmap* bitmap);
  void RenderPerformanceMenu();
  void RenderGridControlsMenu(
      const std::function<void(Command, const CanvasConfig&)>& command_handler,
      CanvasConfig current_config);
  void RenderScalingControlsMenu(
      const std::function<void(Command, const CanvasConfig&)>& command_handler,
      CanvasConfig current_config);
 
  void RenderMaterialIcon(const std::string& icon_name,
                          const ImVec4& color = ImVec4(1, 1, 1, 1));
  std::string GetUsageModeName(CanvasUsage usage) const;
  ImVec4 GetUsageModeColor(CanvasUsage usage) const;
 
  void CreateDefaultMenuItems();
  CanvasMenuItem CreateViewMenuItem(const std::string& label,
                                    const std::string& icon,
                                    std::function<void()> callback);
  CanvasMenuItem CreateBitmapMenuItem(const std::string& label,
                                      const std::string& icon,
                                      std::function<void()> callback);
  CanvasMenuItem CreatePaletteMenuItem(const std::string& label,
                                       const std::string& icon,
                                       std::function<void()> callback);
  CanvasMenuItem CreateBppMenuItem(const std::string& label,
                                   const std::string& icon,
                                   std::function<void()> callback);
  CanvasMenuItem CreatePerformanceMenuItem(const std::string& label,
                                           const std::string& icon,
                                           std::function<void()> callback);
};
 
}  // namespace gui
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_CANVAS_CANVAS_CONTEXT_MENU_H