gcanvas.h

/*
 * File: gcanvas.h
 * ---------------
 *
 * @author Marty Stepp
 * @version 2021/04/09
 * - added sgl namespace
 * - converted Grid functionality to 2D array/vector
 * @version 2019/05/01
 * - added createArgbPixel
 * - bug fixes related to save / setPixels with alpha transparency
 * @version 2019/03/07
 * - added support for loading canvas directly from istream (htiek)
 * @version 2018/09/10
 * - added doc comments for new documentation generation
 * @version 2018/09/04
 * - added double-click event support
 * @version 2018/08/23
 * - renamed to gcanvas.h to replace Java version
 * @version 2018/06/30
 * - initial version
 */


#ifndef _gcanvas_h
#define _gcanvas_h

#include <string>
#include <vector>
#include <QtEvents>
#include <QPainter>
#include "gdrawingsurface.h"
#include "gevent.h"
#include "ginteractor.h"
#include "gobjects.h"

// default color used to highlight pixels that do not match between two images
#define GCANVAS_DEFAULT_DIFF_PIXEL_COLOR 0xdd00dd

namespace sgl {

class _Internal_QCanvas;

class GCanvas : public virtual GInteractor, public virtual GDrawingSurface {
public:
    static const int WIDTH_HEIGHT_MAX;

    static int createArgbPixel(int alpha, int red, int green, int blue);

    static int createRgbPixel(int red, int green, int blue);

    static int getAlpha(int argb);

    static int getBlue(int rgb);

    static int getGreen(int rgb);

    static int getRed(int rgb);

    static void getRedGreenBlue(int rgb, int& red, int& green, int& blue);

    GCanvas(QWidget* parent = nullptr);

    GCanvas(const string& filename, QWidget* parent = nullptr);

    GCanvas(std::istream& filename, QWidget* parent = nullptr);

    GCanvas(double width, double height, int rgbBackground, QWidget* parent = nullptr);

    GCanvas(double width, double height, const string& rgbBackground = "#00000000", QWidget* parent = nullptr);

    ~GCanvas() override;

    virtual void add(GObject* gobj);

    virtual void add(GObject* gobj, double x, double y);

    virtual void add(GObject& gobj);

    virtual void add(GObject& gobj, double x, double y);

    void clear() override;

    virtual void clearObjects();

    virtual void clearPixels();

    virtual bool contains(double x, double y) const;

    virtual int countDiffPixels(const GCanvas& image) const;

    virtual int countDiffPixels(const GCanvas& image, int xmin, int ymin, int xmax, int ymax) const;

    virtual int countDiffPixels(const GCanvas* image) const;

    virtual int countDiffPixels(const GCanvas* image, int xmin, int ymin, int xmax, int ymax) const;

    virtual GCanvas* diff(const GCanvas& image, int diffPixelColor = GCANVAS_DEFAULT_DIFF_PIXEL_COLOR) const;

    virtual GCanvas* diff(const GCanvas* image, int diffPixelColor = GCANVAS_DEFAULT_DIFF_PIXEL_COLOR) const;

    void draw(GObject* gobj) override;

    /* @private */
    /* @inherit */
    void draw(QPainter* painter) override;

    virtual bool equals(const GCanvas& other) const;

    virtual void fill(int rgb);

    virtual void fill(const string& rgb);

    virtual void fillRegion(double x, double y, double width, double height, int rgb);

    virtual void fillRegion(double x, double y, double width, double height,
                            const string& rgb);

    virtual void flatten();

    /* @inherit */
    string getBackground() const override;

    /* @inherit */
    int getBackgroundInt() const override;

    virtual GObject* getElement(int index) const;

    virtual GObject* getElementAt(double x, double y) const;

    virtual int getElementCount() const;

    virtual string getFilename() const;

    /* @inherit */
    string getFont() const override;

    /* @inherit */
    _Internal_QWidget* getInternalWidget() const override;

    int getPixel(double x, double y) const override;

    int getPixelARGB(double x, double y) const override;

    virtual std::vector<std::vector<int>> getPixels() const override;

    int** getPixelsArray() const override;

    virtual std::vector<std::vector<int>> getPixelsARGB() const override;

    int** getPixelsArrayARGB() const override;

    /* @inherit */
    string getType() const override;

    /* @inherit */
    QWidget* getWidget() const override;

    /* @inherit */
    bool isAutoRepaint() const override;

    virtual void load(const string& filename);

    virtual void remove(GObject* gobj);

    virtual void remove(GObject& gobj);

    virtual void removeAll();

    void repaint() override;

    void repaintRegion(int x, int y, int width, int height) override;

    void resize(double width, double height, bool retain = true);

    virtual void save(const string& filename);

    void setAutoRepaint(bool autoRepaint) override;

    /* @inherit */
    void setBackground(int color) override;

    /* @inherit */
    void setBackground(const string& color) override;

    /* @inherit */
    void setColor(int color) override;

    /* @inherit */
    void setColor(const string& color) override;

    /* @inherit */
    void setFont(const QFont& font) override;

    /* @inherit */
    void setFont(const string& font) override;

    /* @inherit */
    void setForeground(int rgb) override;

    /* @inherit */
    void setForeground(const string& color) override;

    void setKeyListener(GEventListener func) override;

    void setKeyListener(GEventListenerVoid func) override;

    void setPixel(double x, double y, int rgb) override;

    void setPixel(double x, double y, int r, int g, int b) override;

    void setPixelARGB(double x, double y, int argb) override;

    void setPixelARGB(double x, double y, int a, int r, int g, int b) override;

    void setPixels(int** pixels, int width = -1, int height = -1) override;

    virtual void setPixels(const std::vector<std::vector<int>>& pixels) override;

    void setPixelsARGB(int** pixelsARGB, int width = -1, int height = -1) override;

    virtual void setPixelsARGB(const std::vector<std::vector<int>>& pixelsARGB) override;

    virtual GImage* toGImage() const;

private:
    Q_DISABLE_COPY(GCanvas)

    _Internal_QCanvas* _iqcanvas;
    GCompound _gcompound;
    QImage* _backgroundImage;
    string _filename;   // file canvas was loaded from; "" if not loaded from a file

    friend class _Internal_QCanvas;

    void ensureBackgroundImage();

    void ensureBackgroundImageConstHack() const;

    void init(double width, double height, int rgbBackground, QWidget* parent);

    virtual bool loadFromStream(std::istream& input);

    void notifyOfResize(double width, double height);
};


class _Internal_QCanvas : public QWidget, public _Internal_QWidget {
    Q_OBJECT

public:
    _Internal_QCanvas(GCanvas* gcanvas, QWidget* parent = nullptr);
    void detach() override;
    void enterEvent(QEvent* event) override;
    void keyPressEvent(QKeyEvent* event) override;
    void keyReleaseEvent(QKeyEvent* event) override;
    void leaveEvent(QEvent* event) override;
    void mouseMoveEvent(QMouseEvent* event) override;
    void mousePressEvent(QMouseEvent* event) override;
    void mouseReleaseEvent(QMouseEvent* event) override;
    void paintEvent(QPaintEvent *event) override;
    void resizeEvent(QResizeEvent* event) override;
    virtual void setCanvasSize(double width, double height);
    QSize sizeHint() const override;
    void wheelEvent(QWheelEvent* event) override;

signals:
    void doubleClicked();

protected:
    void mouseDoubleClickEvent(QMouseEvent* e) override;

private:
    GCanvas* _gcanvas;

    friend class GCanvas;
};

} // namespace sgl

#endif // _gcanvas_h