gobjects.h

/*
 * File: gobjects.h
 * ----------------
 * This file exports a hierarchy of graphical shapes based on
 * the model developed for the ACM Java Graphics.
 * <include src="pictures/ClassHierarchies/GObjectHierarchy-h.html">
 *
 * @author Marty Stepp
 * @version 2021/04/09
 * - added sgl namespace
 * @version 2021/04/03
 * - removed dependency on custom collections
 * @version 2019/05/05
 * - added predictable GLine point ordering
 * @version 2019/04/23
 * - bug fix for loading GImage from file on Windows related to istream change
 * @version 2019/03/07
 * - added support for loading a GImage directly from istream (htiek)
 * @version 2018/09/14
 * - added opacity support
 * - added GCanvas-to-GImage conversion support
 * @version 2018/09/08
 * - added doc comments for new documentation generation
 * @version 2018/08/23
 * - renamed to gobjects.h to replace Java version
 * @version 2018/06/30
 * - initial version
 */


#ifndef _gobjects_h
#define _gobjects_h

#include <initializer_list>
#include <iostream>
#include <vector>
#include <QFont>
#include <QImage>
#include <QPainter>
#include <QPen>
#include <QWidget>

#include "gtypes.h"

namespace sgl {

class GCanvas;
class GCompound;
class GDiffImage;

class GObject {
public:
    enum LineStyle {
        LINE_NONE,
        LINE_SOLID,
        LINE_DASH,
        LINE_DOT,
        LINE_DASH_DOT,
        LINE_DASH_DOT_DOT
    };

    virtual ~GObject();

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

    virtual bool contains(const GPoint& pt) const;

    virtual void draw(QPainter* painter) = 0;

    virtual GPoint getBottomRightLocation() const;

    virtual double getBottomY() const;

    virtual GRectangle getBounds() const;

    virtual GPoint getCenterLocation() const;

    virtual double getCenterX() const;

    virtual double getCenterY() const;

    virtual string getColor() const;

    virtual string getFillColor() const;

    virtual double getHeight() const;

    virtual LineStyle getLineStyle() const;

    virtual double getLineWidth() const;

    virtual GPoint getLocation() const;

    virtual double getOpacity() const;

    virtual GCompound* getParent() const;

    virtual double getRightX() const;

    virtual GDimension getSize() const;

    virtual string getType() const = 0;

    virtual double getWidth() const;

    virtual double getX() const;

    virtual double getY() const;

    static bool isAntiAliasing();

    virtual bool isFilled() const;

    virtual bool isTransformed() const;

    virtual bool isVisible() const;

    virtual void move(double dx, double dy);

    virtual void repaint();

    virtual void resetTransform();

    virtual void rotate(double theta);

    virtual void scale(double sf);

    virtual void scale(double sx, double sy);

    void sendBackward();

    void sendForward();

    void sendToBack();

    void sendToFront();

    static void setAntiAliasing(bool value);

    virtual void setBounds(double x, double y, double width, double height);

    virtual void setBounds(const GRectangle& size);

    virtual void setBottomY(double y);

    virtual void setRightX(double x);

    virtual void setBottomRightLocation(double x, double y);

    virtual void setBottomRightLocation(const GPoint& pt);

    virtual void setCenterX(double x);

    virtual void setCenterY(double y);

    virtual void setCenterLocation(double x, double y);

    virtual void setCenterLocation(const GPoint& pt);

    virtual void setColor(int r, int g, int b);

    virtual void setColor(int rgb);

    virtual void setColor(const string& color);

    virtual void setFillColor(int r, int g, int b);

    virtual void setFillColor(int rgb);

    virtual void setFillColor(const string& color);

    virtual void setFilled(bool flag);

    virtual void setFont(const QFont& font);

    virtual void setFont(const string& font);

    virtual void setForeground(int r, int g, int b);

    virtual void setForeground(int rgb);

    virtual void setForeground(const string& color);

    virtual void setHeight(double height);

    virtual void setLineStyle(LineStyle lineStyle);

    virtual void setLineWidth(double lineWidth);

    virtual void setLocation(double x, double y);

    virtual void setLocation(const GPoint& pt);

    virtual void setOpacity(double opacity);

    virtual void setSize(double width, double height);

    virtual void setSize(const GDimension& size);

    virtual void setVisible(bool flag);

    virtual void setWidth(double width);

    virtual void setX(double x);

    virtual void setY(double y);

    virtual string toString() const;

// Private section
private:
    // forbid assignment between objects
    const GObject& operator =(const GObject&) {
        return *this;
    }

    // forbid copy construction
    GObject(const GObject&) {
        // empty
    }

    // whether to anti-alias graphical objects; default true
    static bool _sAntiAliasing;

    /* Instance variables */
protected:
    double _x;                       // the x coordinate of the origin
    double _y;                       // the y coordinate of the origin
    double _width;                   // the width of the bounding rectangle
    double _height;                  // the height of the bounding rectangle
    double _lineWidth;               // the width of the line in pixels
    double _opacity;                 // 0.0 (transparent) - 1.0 (opaque, default)
    LineStyle _lineStyle;            // line style such as solid or dashed
    string _color;              // the color of the object
    int _colorInt;
    string _fillColor;          // color used to fill the object
    int _fillColorInt;
    string _font;               // the font string of the label
    bool _fillFlag;                  // indicates whether the object is filled
    bool _visible;                   // indicates if object is visible
    bool _transformed;               // indicates if object is transformed
    GCompound* _parent;             // pointer to the parent
    QPen _pen;                       // for outlines
    QBrush _brush;                   // for filling
    QTransform _transform;           // for transformations (rotate, scale)

protected:
    GObject(double x = 0, double y = 0, double width = 0, double height = 0);

    virtual void initializeBrushAndPen(QPainter* painter = nullptr);

    static Qt::PenStyle toQtPenStyle(LineStyle lineStyle);

    virtual string toStringExtra() const;

    friend class GArc;
    friend class GCompound;
    friend class GImage;
    friend class GInteractor;
    friend class GLine;
    friend class GOval;
    friend class GPolygon;
    friend class GRect;
    friend class GRoundRect;
    friend class GText;
};

class GArc : public GObject {
public:
    GArc(double width = 0, double height = 0, double start = 0, double sweep = 0);

    GArc(double x, double y, double width, double height, double start, double sweep);

    /* @inherit */
    bool contains(double x, double y) const override;

    void draw(QPainter* painter) override;

    /* @inherit */
    GRectangle getBounds() const override;

    virtual GPoint getEndPoint() const;

    virtual GRectangle getFrameRectangle() const;

    virtual double getStartAngle() const;

    virtual GPoint getStartPoint() const;

    virtual double getSweepAngle() const;

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

    virtual void setFrameRectangle(const GRectangle& rect);

    virtual void setFrameRectangle(double x, double y, double width, double height);

    virtual void setStartAngle(double start);

    virtual void setSweepAngle(double start);

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

private:
    virtual bool containsAngle(double theta) const;
    virtual GPoint getArcPoint(double theta) const;

    /* Instance variables */
    double _start;                   /* Starting angle of the arc       */
    double _sweep;                   /* How many degrees the arc runs   */
};

class GCompound : public GObject {
public:
    GCompound();

    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);

    virtual void clear();

    virtual void conditionalRepaint();

    virtual void conditionalRepaintRegion(int x, int y, int width, int height);

    virtual void conditionalRepaintRegion(const GRectangle& bounds);

    /* @inherit */
   bool contains(double x, double y) const override;

    void draw(QPainter* painter) override;

    /* @inherit */
    GRectangle getBounds() const override;

    virtual GObject* getElement(int index) const;

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

    virtual int getElementCount() const;

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

    virtual QWidget* getWidget() const;

    virtual bool isAutoRepaint() const;

    virtual bool isEmpty() const;

    virtual void remove(GObject* gobj);

    virtual void remove(GObject& gobj);

    virtual void removeAll();

    void repaint() override;

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

    virtual void repaintRegion(const GRectangle& bounds);

    virtual void setAutoRepaint(bool autoRepaint);

    virtual void setWidget(QWidget* widget);

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

private:
    // methods to move an object in the z-ordering
    void sendBackward(GObject* gobj);
    void sendForward(GObject* gobj);
    void sendToBack(GObject* gobj);
    void sendToFront(GObject* gobj);
    virtual int findGObject(GObject* gobj) const;
    virtual void removeAt(int index);

    // instance variables
    std::vector<GObject*> _contents;
    QWidget* _widget = nullptr;    // widget containing this compound
    bool _autoRepaint;   // automatically repaint on any change; default true

    friend class GObject;
};

class GImage : public GObject {
public:
    GImage(const string& filename = "", double x = 0, double y = 0);

    GImage(std::istream& source, double x = 0, double y = 0);

    GImage(double width, double height);

    virtual ~GImage();



    void draw(QPainter* painter) override;

    virtual string getFileName() const;

    virtual int getPixel(int x, int y) const;

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

    virtual void setPixel(int x, int y, int rgb);

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

protected:
    GImage(QImage* qimage);

    QImage* getQImage() const;

private:
    bool load(const string& filename);

    bool loadFromStream(std::istream& input);

    string _filename;
    QImage* _qimage;

    friend class GCanvas;
    friend class GDiffImage;
};

class GLine : public GObject {
public:
    GLine(double x0 = 0, double y0 = 0, double x1 = 0, double y1 = 0, LineStyle lineStyle = LINE_SOLID);

    GLine(const GPoint& p0, const GPoint& p1);

    /* @inherit */
    bool contains(double x, double y) const override;

    void draw(QPainter* painter) override;

    /* @inherit */
    GRectangle getBounds() const override;

    virtual GPoint getEndPoint() const;

    virtual double getEndX() const;

    virtual double getEndY() const;

    /* @inherit */
    double getHeight() const override;

    virtual GPoint getStartPoint() const;

    virtual double getStartX() const;

    virtual double getStartY() const;

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

    /* @inherit */
    double getWidth() const override;

    virtual void setEndPoint(double x1, double y1);

    virtual void setEndPoint(const GPoint& p);

    virtual void setPoints(double x0, double y0, double x1, double y1);

    virtual void setPoints(const GPoint& p0, const GPoint& p1);

    virtual void setStartPoint(double x0, double y0);

    virtual void setStartPoint(const GPoint& p);

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

protected:
    /* Instance variables */
    double _dx;   // the x displacement of the line
    double _dy;   // the y displacement of the line
};

class GOval : public GObject {
public:
    GOval(double x = 0, double y = 0, double width = 0, double height = 0);

    /* @inherit */
   bool contains(double x, double y) const override;

    void draw(QPainter* painter) override;

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

class GPolygon : public GObject {
public:
    GPolygon();

    GPolygon(std::initializer_list<double> coords);
    GPolygon(std::initializer_list<GPoint> points);

    virtual void addEdge(double dx, double dy);

    virtual void addEdge(const GPoint& pt);

    virtual void addEdges(std::initializer_list<double> coords);

    virtual void addEdges(std::initializer_list<GPoint> points);

    virtual void addPolarEdge(double r, double theta);

    virtual void addVertex(double x, double y);

    virtual void addVertex(const GPoint& pt);

    virtual void addVertexes(std::initializer_list<double> coords);

    virtual void addVertexes(std::initializer_list<GPoint> points);

    virtual void clear();

    /* @inherit */
    bool contains(double x, double y) const override;

    void draw(QPainter* painter) override;

    /* @inherit */
    GRectangle getBounds() const override;

    /* @inherit */
    double getHeight() const override;

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

    virtual GPoint getVertex(int i) const;

    virtual int getVertexCount() const;

    virtual std::vector<GPoint> getVertices() const;

    /* @inherit */
    double getWidth() const override;

    virtual void setVertex(int i, GPoint point);

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

private:
    /* Instance variables */
    QVector<QPointF> _vertices;   // the vertices of the polygon
    double _cx;                   // the most recent x coordinate
    double _cy;                   // the most recent y coordinate
};

class GRect : public GObject {
public:
    GRect(double x = 0, double y = 0, double width = 0, double height = 0);

    void draw(QPainter* painter) override;

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

class GRoundRect : public GRect {
public:
    static const double DEFAULT_CORNER;

    GRoundRect(double width = 0, double height = 0, double corner = DEFAULT_CORNER);

    GRoundRect(double x, double y, double width, double height, double corner = DEFAULT_CORNER);

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

    void draw(QPainter* painter) override;

    virtual double getCorner() const;

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

    virtual void setCorner(double corner);

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

protected:
    double _corner;
};

class GText : public GObject {
public:
    static const string DEFAULT_FONT;

    GText(const string& str = "", double x = 0, double y = 0);

    void draw(QPainter* painter) override;

    /* @inherit */
    GRectangle getBounds() const override;

    virtual string getFont() const;

    virtual double getFontAscent() const;

    virtual double getFontDescent() const;

    virtual string getLabel() const;

    virtual string getText() const;

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

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

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

    virtual void setLabel(const string& str);

    virtual void setText(const string& str);

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

private:
    /* Instance variables */
    string _text;   // the string displayed by the label
    QFont _qfont;

    // update width and height when font or text changes
    void updateSize();
};

std::ostream& operator <<(std::ostream& out, const GObject& obj);

} // namespace sgl

#endif // _gobjects_h