pixel_editor_panel.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_GRAPHICS_PIXEL_EDITOR_PANEL_H
#define YAZE_APP_EDITOR_GRAPHICS_PIXEL_EDITOR_PANEL_H
 
#include <functional>
#include <optional>
 
#include "absl/status/status.h"
#include "app/editor/core/undo_manager.h"
#include "app/editor/graphics/graphics_editor_state.h"
#include "app/editor/graphics/palette_reorder_control.h"
#include "app/editor/graphics/pixel_clipboard.h"
#include "app/editor/system/editor_panel.h"
#include "app/gfx/core/bitmap.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/icons.h"
#include "rom/rom.h"
#include "zelda3/graphics_sheet_store.h"
 
namespace yaze {
namespace editor {
 
class PixelEditorPanel : public WindowContent {
 public:
  explicit PixelEditorPanel(GraphicsEditorState* state, Rom* rom,
                            UndoManager* undo_manager = nullptr)
      : state_(state), rom_(rom), undo_manager_(undo_manager) {}
 
  // ==========================================================================
  // WindowContent Identity
  // ==========================================================================
 
  std::string GetId() const override { return "graphics.pixel_editor"; }
  std::string GetDisplayName() const override { return "Pixel Editor"; }
  std::string GetIcon() const override { return ICON_MD_BRUSH; }
  std::string GetEditorCategory() const override { return "Graphics"; }
  int GetPriority() const override { return 20; }
 
  // ==========================================================================
  // WindowContent Lifecycle
  // ==========================================================================
 
  void Initialize();
 
  void SetRom(Rom* rom) { rom_ = rom; }
  // The Graphics owner supplies its existing Usage Preview; no second renderer.
  void SetSourcePreviewCallback(std::function<void()> draw) {
    draw_source_preview_ = std::move(draw);
  }
  void ShowSourcePreview() { show_source_preview_ = true; }
  void SetScratchCallback(std::function<void()> open) {
    open_scratch_ = std::move(open);
  }
  // Visibility belongs to the workspace manager, including saved layouts.
  void SetSheetBrowserCallbacks(std::function<bool()> visible,
                                std::function<void(bool)> set_visible) {
    sheet_browser_visible_ = std::move(visible);
    set_sheet_browser_visible_ = std::move(set_visible);
  }
 
  void Draw(bool* p_open) override;
 
  absl::Status Update();
 
  // System clipboard (PNG); Cut/Copy/Paste shortcuts route here through
  // GraphicsEditor. Copy takes the selection, or the whole sheet.
  void CopyToSystemClipboard();
  void CutToSystemClipboard();
  void PasteFromSystemClipboard();
 
  bool HasActiveStroke() const { return stroke_.has_value(); }
  // Explicit navigation commits the current gesture before its target changes.
  void FinishGesture();
  // A hidden panel may miss the release frame; button-up still finishes it.
  void FinishReleasedGesture();
  void SetHistoryCallbacks(std::function<absl::Status()> undo,
                           std::function<absl::Status()> redo) {
    undo_ = std::move(undo);
    redo_ = std::move(redo);
  }
  void SetPaletteReorderCallback(PaletteReorderControl::Apply apply) {
    apply_palette_reorder_ = std::move(apply);
  }
 
 private:
  std::function<absl::Status()> undo_;
  std::function<absl::Status()> redo_;
  std::string history_error_;
  PixelTool gesture_tool_ = PixelTool::kPencil;
  PaletteReorderControl palette_reorder_;
  PaletteReorderControl::Apply apply_palette_reorder_;
  void DrawSourceContext();
  // A palette-only display copy. Pixel tools still write the session store.
  gfx::Bitmap& DisplaySheet();
  gfx::SnesPalette DisplayPalette() const;
  gfx::Bitmap context_sheet_;
  bool fit_canvas_requested_ = false;
  bool show_source_preview_ = true;
  std::function<void()> draw_source_preview_;
  std::function<void()> open_scratch_;
  std::function<bool()> sheet_browser_visible_;
  std::function<void(bool)> set_sheet_browser_visible_;
  void DrawToolbar();
 
  void DrawViewControls();
 
  void DrawCanvas();
 
  void DrawColorPicker();
 
  void DrawIndexSwapControls();
  int swap_from_id_ = 1;
  int swap_to_id_ = 2;
  int swap_scope_ = 0;
  std::string index_swap_status_;
 
  void DrawStatusBar();
 
  void DrawMiniMap();
 
  void HandleCanvasInput();
 
  void ApplyPencil(int x, int y);
 
  void ApplyBrush(int x, int y);
 
  void ApplyEraser(int x, int y);
 
  void ApplyFill(int x, int y);
 
  void ApplyEyedropper(int x, int y);
 
  void DrawLine(int x1, int y1, int x2, int y2);
 
  void DrawRectangle(int x1, int y1, int x2, int y2, bool filled);
 
  void BeginSelection(int x, int y);
 
  void UpdateSelection(int x, int y);
 
  void EndSelection();
 
  void CopySelection();
 
  void PasteSelection(int x, int y);
 
  void FlipSelectionHorizontal();
 
  void FlipSelectionVertical();
 
  void BeginStroke();
 
  void EndStroke();
 
  zelda3::GraphicsSheetStore::Edit* StrokeEdit();
 
  void ShowStrokeChanges(bool changed);
 
  ImVec2 ScreenToPixel(ImVec2 screen_pos);
 
  ImVec2 PixelToScreen(int x, int y);
 
  // ==========================================================================
  // Overlay Drawing
  // ==========================================================================
 
  void DrawTransparencyGrid(float canvas_width, float canvas_height);
 
  void DrawCursorCrosshair();
 
  void DrawBrushPreview();
 
  void DrawPixelInfoTooltip(const gfx::Bitmap& sheet);
 
  void DrawTileHighlight(const gfx::Bitmap& sheet);
 
  friend class PixelEditorPanelTestPeer;
  friend class AuthoringSaveWorkflowTestPeer;
 
  GraphicsEditorState* state_;
  Rom* rom_;
  UndoManager* undo_manager_ = nullptr;
  gui::Canvas canvas_{"PixelEditorCanvas", ImVec2(128, 32),
                      gui::CanvasGridSize::k8x8};
 
  // The stroke in progress (mouse-down to mouse-up, or one paste or cut).
  std::optional<zelda3::GraphicsSheetStore::Edit> stroke_;
 
  // Mouse tracking for tools
  bool is_drawing_ = false;
  ImVec2 last_mouse_pixel_ = {-1, -1};
  ImVec2 tool_start_pixel_ = {-1, -1};
 
  // Line/rectangle preview
  bool show_tool_preview_ = false;
  ImVec2 preview_end_ = {0, 0};
 
  // Current cursor position in pixel coords
  int cursor_x_ = 0;
  int cursor_y_ = 0;
  bool cursor_in_canvas_ = false;
 
  // System clipboard (PNG). Copy takes the selection, or the whole sheet
  // when nothing is selected. Paste maps the image onto the sheet's colors
  // and floats it as the selection until committed (Enter, or a click
  // outside it) or cancelled (Esc); a commit is one undo step.
  void HandleFloatingPasteKeys();
  void DrawClipboardControls();
  void DrawFloatingPaste();
  bool HandleFloatingPasteInput();  // true while the float takes the mouse
  void CommitFloatingPaste();
  void CancelFloatingPaste();
  void ClampFloatingPaste();
  SheetColors CurrentSheetColors() const;
  std::string clipboard_status_;
  bool clipboard_status_is_error_ = false;
  bool paste_skip_color0_ = false;
  bool dragging_paste_ = false;
  int paste_drag_dx_ = 0;
  int paste_drag_dy_ = 0;
 
  // Canvas panning (Hand tool, or the middle mouse button with any tool).
  bool HandlePanInput();
  void DrawPaletteRowPicker();
  void DrawPixelGrids(float canvas_width, float canvas_height);
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_GRAPHICS_PIXEL_EDITOR_PANEL_H