PixelCanvas.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <QPointF>
#include <QSize>
#include <QWidget>
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include "HMI/Editor/EditContextTarget.h"
#include "HMI/Editor/PixelCanvasGeometry.h"
#include "HMI/Editor/PixelHistory.h"
#include "HMI/Editor/PixelOperations.h"
#include "HMI/Editor/PixelTool.h"
#include "HMI/Graphics/TextureLoader.h"
 
class QEvent;
class QMouseEvent;
class QPaintEvent;
class QPixmap;
class QWheelEvent;
 
namespace hmi {
class Localization;
}  // namespace hmi

 
namespace hmi {

class PixelCanvas : public QWidget, public EditContextTarget {
    Q_OBJECT
 
public:
    explicit PixelCanvas(QWidget* parent = nullptr);

    void setLocalization(const Localization* loc) noexcept {
        _loc = loc;
    }

    void setImage(DecodedImage image);

    void setUnderlay(DecodedImage image, float opacity = 1.0f);

    void setOverlay(DecodedImage image, float opacity = 1.0f);

    void setReferenceGridStep(int step);
    [[nodiscard]] const DecodedImage& image() const noexcept {
        return _image;
    }

    void setAssetName(std::string name) {
        _assetName = std::move(name);
    }
    [[nodiscard]] const std::string& assetName() const noexcept {
        return _assetName;
    }

    [[nodiscard]] bool isDirty() const noexcept {
        return _dirty;
    }

    void markSaved() noexcept {
        _dirty = false;
    }
 
    void setActiveTool(PixelTool tool) noexcept {
        _activeTool = tool;
    }
    [[nodiscard]] PixelTool activeTool() const noexcept {
        return _activeTool;
    }

    void setCurrentColor(std::uint32_t color);
    [[nodiscard]] std::uint32_t currentColor() const noexcept {
        return _currentColor;
    }

    void setPaletteColors(std::vector<std::uint32_t> colors) {
        _paletteColors = std::move(colors);
    }

    void setPaletteConstrained(bool enabled) noexcept {
        _paletteConstrained = enabled;
    }
    [[nodiscard]] bool paletteConstrained() const noexcept {
        return _paletteConstrained;
    }
 
    [[nodiscard]] const PixelHistory& history() const noexcept {
        return _history;
    }
 
    // hmi::EditContextTarget (TACHE-04/TACHE-06) : Annuler/Refaire/Copier/Coller à cible
    // contextuelle (EX-IHM-062).
    [[nodiscard]] bool canUndo() const override {
        return _history.canUndo();
    }
    void undo() override;
    [[nodiscard]] bool canRedo() const override {
        return _history.canRedo();
    }
    void redo() override;
    void jumpHistoryTo(std::size_t index);
    [[nodiscard]] bool canCopy() const override {
        return _image.width > 0 && _image.height > 0;
    }

    void copy() override;
    [[nodiscard]] bool canPaste() const override {
        return !_clipboard.empty();
    }

    void paste() override;

    [[nodiscard]] int referenceGridStep() const noexcept {
        return _referenceGridStep;
    }

    [[nodiscard]] const PixelRegion& selection() const noexcept {
        return _selection;
    }

    void applyFlipHorizontal();
    void applyFlipVertical();
    void applyRotateClockwise();
    void applyRotateCounterClockwise();
 
    [[nodiscard]] const PixelCanvasView& view() const noexcept {
        return _view;
    }
    void zoomIn();
    void zoomOut();

    [[nodiscard]] std::optional<std::pair<int, int>> imagePixelAt(
        const QPointF& widgetPosition) const;
    [[nodiscard]] std::optional<std::pair<int, int>> hoveredPixel() const noexcept {
        return _hoveredPixel;
    }
 
    [[nodiscard]] QSize sizeHint() const override;
 
signals:
    void imageChanged();
    void historyChanged();
    void hoveredPixelChanged(std::optional<std::pair<int, int>> pixel);
    void currentColorChanged(std::uint32_t color);
 
protected:
    void paintEvent(QPaintEvent* event) override;
    void mousePressEvent(QMouseEvent* event) override;
    void mouseMoveEvent(QMouseEvent* event) override;
    void mouseReleaseEvent(QMouseEvent* event) override;
    void leaveEvent(QEvent* event) override;
    void wheelEvent(QWheelEvent* event) override;
 
private:
    [[nodiscard]] QPixmap renderPixmap() const;

    void applyToolAtPoint(int x, int y);
    void continueToolTo(int x, int y);
    void beginGesture(int x, int y);
    void endGesture();

    [[nodiscard]] PixelRegion effectiveRegion() const;
    void commitRegionMutation(PixelOperationKind kind, const DecodedImage& beforeSnapshot,
                              const PixelRegion& touched);
    void applyRegionOperation(PixelOperationKind kind,
                              PixelRegion (*operation)(DecodedImage&, const PixelRegion&));
    [[nodiscard]] std::uint32_t effectivePaintColor() const noexcept;
 
    DecodedImage _image;
    DecodedImage _underlay;
    float _underlayOpacity = 1.0f;
    DecodedImage _overlay;
    float _overlayOpacity = 1.0f;
    int _referenceGridStep = 0;
    std::string _assetName;
    bool _dirty = false;
    PixelHistory _history;
    PixelCanvasView _view;
    PixelTool _activeTool = PixelTool::Brush;
    std::uint32_t _currentColor = 0xFF000000u;  // noir opaque (R8G8B8A8_UNORM, LOT-54 TACHE-01).
    std::vector<std::uint32_t> _paletteColors;  
    bool _paletteConstrained = false;
 
    bool _gestureActive = false;
    DecodedImage _gestureBeforeSnapshot;  
    PixelRegion _gestureRegion;           
    std::optional<std::pair<int, int>> _lastGesturePixel;
    std::optional<std::pair<int, int>> _hoveredPixel;
 
    // Outils de région (LOT-54 TACHE-06).
    PixelRegion _selection;             
    PixelClipboard _clipboard;          
    bool _selectionMoveActive = false;  
    std::pair<int, int> _selectionDragAnchor{0, 0};  
 
    bool _panning = false;
    QPointF _panStartWidgetPos;
    PixelCanvasView _panStartView;
 
    const Localization* _loc = nullptr;  
};
 
}  // namespace hmi