canvas_menu.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_CANVAS_CANVAS_MENU_H
#define YAZE_APP_GUI_CANVAS_CANVAS_MENU_H
 
#include <functional>
#include <optional>
#include <string>
#include <vector>
 
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
enum class MenuSectionPriority {
  kEditorSpecific = 0,     // Highest priority - editor-specific actions
  kBitmapPalette = 10,     // Medium priority - bitmap/palette operations
  kCanvasProperties = 20,  // Low priority - canvas settings
  kDebug = 30              // Lowest priority - debug/performance
};
 
struct CanvasPopupDefinition {
  // Unique popup identifier for ImGui
  std::string popup_id;
 
  // Callback that renders the popup content (should call
  // ImGui::BeginPopup/EndPopup)
  std::function<void()> render_callback;
 
  // Whether to automatically open the popup when menu item is selected
  bool auto_open_on_select = true;
 
  // Whether the popup should persist across frames until explicitly closed
  bool persist_across_frames = true;
 
  // Default constructor
  CanvasPopupDefinition() = default;
 
  // Constructor for simple popups
  CanvasPopupDefinition(const std::string& id, std::function<void()> callback)
      : popup_id(id), render_callback(std::move(callback)) {}
};
 
struct CanvasMenuItem {
  // Display label for the menu item
  std::string label;
 
  // Optional icon (Material Design icon name or Unicode glyph)
  std::string icon;
 
  // Optional keyboard shortcut display (e.g., "Ctrl+S")
  std::string shortcut;
 
  // Optional hover tooltip. On an armed confirm-gated item it replaces the
  // default "This cannot be undone." warning.
  std::string tooltip;
 
  // Callback invoked when menu item is selected
  std::function<void()> callback;
 
  // Optional popup definition - if present, popup will be managed automatically
  std::optional<CanvasPopupDefinition> popup;
 
  // Condition to determine if menu item is enabled
  std::function<bool()> enabled_condition = []() {
    return true;
  };
 
  // Condition to determine if menu item is visible
  std::function<bool()> visible_condition = []() {
    return true;
  };
 
  // Optional checked state for toggle-like menu items.
  std::function<bool()> checked_condition;
 
  // Nested submenu items
  std::vector<CanvasMenuItem> subitems;
 
  // Color for the menu item label
  ImVec4 color = ImVec4(1, 1, 1, 1);
 
  // Whether to show a separator after this item
  bool separator_after = false;
 
  // Destructive action (delete, forget, close-with-unsaved-changes). The label
  // renders in gui::GetErrorColor() and overrides `color`.
  bool destructive = false;
 
  // Two-step confirmation ("click again to confirm"). The first click arms the
  // item: the menu stays open and the label becomes "Confirm <label>?". The
  // second click runs the callback and closes the menu. Closing the menu or
  // clicking another confirm-gated item disarms it. Label such items with a
  // trailing "..." (see docs/internal/gui/context-menus.md).
  bool requires_confirmation = false;
 
  // Default constructor
  CanvasMenuItem() = default;
 
  // Simple menu item constructor
  CanvasMenuItem(const std::string& lbl, std::function<void()> cb)
      : label(lbl), callback(std::move(cb)) {}
 
  // Menu item with icon
  CanvasMenuItem(const std::string& lbl, const std::string& ico,
                 std::function<void()> cb)
      : label(lbl), icon(ico), callback(std::move(cb)) {}
 
  // Menu item with icon and shortcut
  CanvasMenuItem(const std::string& lbl, const std::string& ico,
                 std::function<void()> cb, const std::string& sc)
      : label(lbl), icon(ico), callback(std::move(cb)), shortcut(sc) {}
 
  // Helper to create a destructive item. With `confirm` true the callback only
  // runs after the two-step confirmation described on requires_confirmation.
  static CanvasMenuItem Destructive(const std::string& lbl,
                                    const std::string& ico,
                                    std::function<void()> cb,
                                    bool confirm = true,
                                    const std::string& sc = "") {
    CanvasMenuItem item(lbl, ico, std::move(cb), sc);
    item.destructive = true;
    item.requires_confirmation = confirm;
    return item;
  }
 
  // Helper to create a disabled menu item
  static CanvasMenuItem Disabled(const std::string& lbl) {
    CanvasMenuItem item;
    item.label = lbl;
    item.enabled_condition = []() {
      return false;
    };
    return item;
  }
 
  // Helper to create a conditional menu item
  static CanvasMenuItem Conditional(const std::string& lbl,
                                    std::function<void()> cb,
                                    std::function<bool()> condition) {
    CanvasMenuItem item;
    item.label = lbl;
    item.callback = std::move(cb);
    item.enabled_condition = std::move(condition);
    return item;
  }
 
  // Helper to create a menu item with popup
  static CanvasMenuItem WithPopup(const std::string& lbl,
                                  const std::string& popup_id,
                                  std::function<void()> render_callback) {
    CanvasMenuItem item;
    item.label = lbl;
    item.popup = CanvasPopupDefinition(popup_id, std::move(render_callback));
    return item;
  }
};
 
struct CanvasMenuSection {
  // Optional section title (rendered as colored text)
  std::string title;
 
  // Color for section title
  ImVec4 title_color = ImVec4(0.7f, 0.7f, 0.7f, 1.0f);
 
  // Menu items in this section
  std::vector<CanvasMenuItem> items;
 
  // Whether to show a separator after this section
  bool separator_after = true;
 
  // Priority for ordering sections (lower values render first)
  MenuSectionPriority priority = MenuSectionPriority::kEditorSpecific;
 
  // Default constructor
  CanvasMenuSection() = default;
 
  // Constructor with title
  explicit CanvasMenuSection(const std::string& t) : title(t) {}
 
  // Constructor with title and items
  CanvasMenuSection(const std::string& t,
                    const std::vector<CanvasMenuItem>& its)
      : title(t), items(its) {}
 
  // Constructor with title, items, and priority
  CanvasMenuSection(const std::string& t,
                    const std::vector<CanvasMenuItem>& its,
                    MenuSectionPriority prio)
      : title(t), items(its), priority(prio) {}
};
 
struct CanvasMenuDefinition {
  // Menu sections (rendered in order)
  std::vector<CanvasMenuSection> sections;
 
  // Whether the menu is enabled
  bool enabled = true;
 
  // Default constructor
  CanvasMenuDefinition() = default;
 
  // Constructor with sections
  explicit CanvasMenuDefinition(const std::vector<CanvasMenuSection>& secs)
      : sections(secs) {}
 
  // Add a section
  void AddSection(const CanvasMenuSection& section) {
    sections.push_back(section);
  }
 
  // Add items without a section title
  void AddItems(const std::vector<CanvasMenuItem>& items) {
    CanvasMenuSection section;
    section.items = items;
    section.separator_after = false;
    sections.push_back(section);
  }
};
 
using MenuItemSpec = CanvasMenuItem;
 
class MenuConfirmState {
 public:
  // Record that the item `id` was rendered on `frame`. Disarms a stale arm.
  void NoteRendered(ImGuiID id, int frame);
 
  // True when `id` is armed and was rendered on the previous or current frame.
  bool IsArmed(ImGuiID id, int frame) const;
 
  // Handle a click on `id`. Returns true when the action should run (second
  // click on an armed item); otherwise arms `id` and returns false.
  bool Click(ImGuiID id, int frame);
 
  void Reset() {
    armed_id_ = 0;
    last_frame_ = -1;
  }
 
  ImGuiID armed_id() const { return armed_id_; }
 
 private:
  ImGuiID armed_id_ = 0;
  int last_frame_ = -1;
};
 
// Process-wide confirm state shared by every RenderMenuItem call.
MenuConfirmState& GetMenuConfirmState();
 
// Label shown on an armed confirm-gated item: "Confirm <label>?" with any
// trailing "..." or ellipsis removed.
std::string ConfirmLabel(const std::string& label);
 
class PopupStyleScope {
 public:
  PopupStyleScope();
  ~PopupStyleScope();
  PopupStyleScope(const PopupStyleScope&) = delete;
  PopupStyleScope& operator=(const PopupStyleScope&) = delete;
 
 private:
  int pushed_ = 0;
};
 
// Value of a two-float style var before the first PushStyleVar of it that is
// still on the style stack; the current value when nothing pushed it.
ImVec2 BaseStyleVarVec2(ImGuiStyleVar idx);
 
// ==================== Free Function API ====================
 
void RenderMenuItem(
    const CanvasMenuItem& item,
    std::function<void(const std::string&, std::function<void()>)>
        popup_opened_callback = nullptr);
 
void RenderMenuSection(
    const CanvasMenuSection& section,
    std::function<void(const std::string&, std::function<void()>)>
        popup_opened_callback = nullptr);
 
void RenderCanvasMenu(
    const CanvasMenuDefinition& menu,
    std::function<void(const std::string&, std::function<void()>)>
        popup_opened_callback = nullptr);
 
}  // namespace gui
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_CANVAS_CANVAS_MENU_H