shape.h

#ifndef SHAPE_H
#define SHAPE_H

#include "canvascv/colors.h"
#include "canvascv/consts.h"

#include <opencv2/core/mat.hpp>
#include <string>
#include <list>
#include <iostream>
#include <memory>
#include <functional>

namespace canvascv
{

class Handle;
class Canvas;

class Shape
{
public:

    Shape();

    Shape(const Shape &other);

    virtual ~Shape();

    enum Event
    {
        SELECT,   
        UNSELECT, 
        REMOVED   
    };

    typedef std::function<void(Shape*, Event)> CBPerShape;

    void notifyOnEvent(CBPerShape cb);


    virtual std::list<Handle*> getConnectionTargets() = 0;


    cv::Scalar getOutlineColor() const;

    virtual void setOutlineColor(const cv::Scalar &value);

    cv::Scalar getFillColor() const;

    virtual void setFillColor(const cv::Scalar &value);

    bool getLocked() const;

    virtual void setLocked(bool value);

    bool getVisible() const;

    virtual void setVisible(bool value);

    virtual const char *getType() const = 0;

    int getThickness() const;

    virtual void setThickness(int value);

    int getLineType() const;

    virtual void setLineType(int value);

    virtual bool isAtPos(const cv::Point &pos) = 0;

    virtual void translate(const cv::Point &offset) = 0;

    bool isReady() const;

    int getId();

protected:
    virtual void writeInternals(cv::FileStorage& fs) const = 0;
    virtual void readInternals(const cv::FileNode& node) = 0;

    virtual bool mousePressed(const cv::Point &pos, bool onCreate = false) = 0;

    virtual bool mouseMoved(const cv::Point &pos) = 0;

    virtual std::shared_ptr<Shape> getShape(int id);

    virtual bool keyPressed(int &key);

    virtual void lostFocus();

    virtual bool mouseReleased(const cv::Point &pos) = 0;

    bool isEditing();

    virtual void draw(cv::Mat &canvas) = 0;

    void drawHelper(cv::Mat &canvas, Shape *other);

    const std::string &getStatusMsg() const;
    virtual const std::string &getCreateStatusMsg() const = 0;
    virtual const std::string &getEditStatusMsg() const = 0;

    void setCanvas(Canvas &value);

    void setDeleted();

    bool isDeleted();

    virtual void setReady();

    int id;
    cv::Scalar outlineColor;
    cv::Scalar fillColor;
    bool locked;
    bool visible;
    bool editing;
    int thickness;
    int lineType;
    Canvas *canvas;

private:
    friend void read(const cv::FileNode& node, Canvas& x, const Canvas&);
    friend class Canvas;
    friend class CompoundShape;

    void broadcastEvent(Event event);

    int genId();

    friend void write(cv::FileStorage& fs, const std::string&, const Shape& x);
    friend void read(const cv::FileNode& node, Shape*& x, const Shape* default_value);

    void write(cv::FileStorage& fs) const;
    void read(const cv::FileNode& node);

    std::list<CBPerShape> cbs;
    bool deleted;
    bool ready;
};

// These write and read functions must be defined for the serialization in cv::FileStorage to work
void write(cv::FileStorage& fs, const std::string&, const Shape& x);
void read(const cv::FileNode& node, Shape*& x, const Shape* default_value);

// Will write the xml to memory and output it's std::string
std::ostream & operator<<(std::ostream& o, const Shape &shape);

}

#endif // SHAPE_H