canvas.h

#ifndef CANVAS_H
#define CANVAS_H

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

#include "shapes/shape.h"
#include "widgets/widget.h"
#include "shapes/shapefactory.h"
#include "widgets/widgetfactory.h"
#include "widgets/text.h"
#include "widgets/layoutbase.h"

#include <list>
#include <memory>
#include <functional>
#include <sstream>

namespace canvascv
{

class Canvas : public LayoutBase
{
public:
    typedef std::function<void(Shape*)> CBCanvasShape;

    Canvas(const std::string &winNameVal, cv::Size sizeVal = cv::Size());

    ~Canvas();

    void redrawOn(const cv::Mat &src, cv::Mat &dst);


    void redrawOn(cv::Mat &dst);

    void setImage(const cv::Mat &img);

    bool onMousePress(const cv::Point &pos);

    void onMouseRelease(const cv::Point &pos);

    void onMouseMove(const cv::Point &pos);

    std::shared_ptr<Shape> createShape(std::string type, const cv::Point &pos = cv::Point(0,0));

    template <class T>
    std::shared_ptr<T> createShape(const cv::Point &pos = cv::Point(0,0));

    std::string getShapeType() const
    {
        return shapeType;
    }

    void setShapeType(std::string value)
    {
        shapeType = value;
    }

    void deleteActive();

    void deleteShape(const std::shared_ptr<Shape> &shape);

    void deleteWidget(const std::shared_ptr<Widget> &widget);

    void notifyOnShapeCreate(CBCanvasShape cb);

    void notifyOnShapeModify(CBCanvasShape cb);

    void notifyOnShapeDelete(CBCanvasShape cb);

    void clearShapes();

    void clearWidgets();

    template <class T>
    void getShapes(std::list<std::shared_ptr<T>> &result);

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

    void getShapes(const cv::Point &pos, std::list<std::shared_ptr<Shape>> &result);

    void disableScreenText()
    {
        hasScreenText = false;
    }

    void disableStatusMsg()
    {
        hasStatusMsg = false;
    }

    void enableScreenText(cv::Scalar color = Colors::Black,
                          cv::Scalar bgColor = Colors::LightGray,
                          double scale = Consts::DEFAULT_FONT_SCALE,
                          int thickness = Consts::DEFAULT_FONT_THICKNESS,
                          uchar alpha = 80,
                          int fontFace = Consts::DEFAULT_FONT);

    void enableStatusMsg(cv::Scalar color = Colors::Orange,
                         cv::Scalar bgColor = Colors::LightGray,
                         double scale = Consts::DEFAULT_FONT_SCALE,
                         int thickness = Consts::DEFAULT_FONT_THICKNESS,
                         uchar alpha = 80,
                         int fontFace = Consts::DEFAULT_FONT);

    void setDefaultStatusMsg(const std::string &msg);

    std::string getDefaultStatusMsg() const;

    void setScreenText(const std::string &msg);

    void setSize(const cv::Size &value);

    cv::Size getSize();

    virtual void addWidget(const std::shared_ptr<Widget> &widget);
    virtual std::shared_ptr<Widget> rmvWidget(const std::shared_ptr<Widget> &widget);

    bool getOn() const;

    void setOn(bool value);

    void writeShapesToFile(const std::string &filepath) const;

    void readShapesFromFile(const std::string &filepath);

    void setMouseCallback();

    void imshow(InputArray mat);

    int waitKeyEx(int delay = 0);

    void applyTheme(bool applyToCanvasText = false);

    static void fatal(string errorMsg, int exitStatus);

    void setDirty();

protected:
    virtual void recalc() {}

    virtual std::shared_ptr<Widget> rmvWidget(Widget *widget);


    virtual const cv::Rect getBoundaries() const;

private:

    Canvas();

    class StatusMsgGrd
    {
    public:
        StatusMsgGrd(Canvas &val) : c(val) {}
        ~StatusMsgGrd()
        {
            if (c.activeWidget)
            {
                c.setStatusMsg(c.activeWidget->getStatusMsg());
            }
            else if (c.activeShape)
            {
                c.setStatusMsg(c.activeShape->getStatusMsg());
            }
            else
            {
                c.setStatusMsg(c.defaultStatusMsg);
            }
        }
    private:
        Canvas &c;
    };
    friend class StatusMsgGrd;

    void consumeKey(int &key);

    void setStatusMsg(const std::string &msg);

    virtual bool setDirtyLayout();

    void broadcastCreate(Shape *shape);
    void broadcastModify(Shape *shape);
    void broadcastDelete(Shape *shape);

    void processNewShape();

    bool on;
    bool isDirty;
    cv::Rect boundaries;
    bool hasScreenText;
    bool hasStatusMsg;
    std::shared_ptr<Text> screenText;
    std::shared_ptr<Text> statusMsg;
    std::string defaultStatusMsg;
    std::string shapeType;
    cv::Point dragPos;
    cv::Mat latestFrameSrc;
    std::string winName;
    std::list<std::shared_ptr<Shape>> shapes;
    std::list<std::shared_ptr<Widget>> widgets;
    std::shared_ptr<Shape> activeShape;
    std::shared_ptr<Widget> activeWidget;
    std::list<CBCanvasShape> createNotifs;
    std::list<CBCanvasShape> modifyNotifs;
    std::list<CBCanvasShape> deleteNotifs;

    friend void operator >> (const cv::FileNode& n, Canvas& value)
    {
        read( n, value, Canvas());
    }

    friend void write(cv::FileStorage& fs, const std::string&, const Canvas& x);
    friend void read(const cv::FileNode& node, Canvas& x, const Canvas&);
};

template <class T>
std::shared_ptr<T> Canvas::createShape(const cv::Point &pos)
{
    std::shared_ptr<T> shape(ShapeFactoryT<T>::newShape(pos));
    shapes.push_back(shape);
    processNewShape();
    ((Shape*)shape.get())->setReady();
    ((Shape*)shape.get())->setLocked(false); // (Maybe better is setReady does this for the needed shape)
    ((Shape*)shape.get())->lostFocus();
    activeShape.reset();
    return shape;
}

template <class T>
void Canvas::getShapes(std::list<std::shared_ptr<T>> &result)
{
    for (auto &shape : shapes)
    {
        std::shared_ptr<T> derived = std::dynamic_pointer_cast<T>(shape);
        if (derived.get())
        {
            result.push_back(derived);
        }
    }
}

void writeShapes(cv::FileStorage& fs, const std::string&, const Canvas& x);
void readShapes(const cv::FileNode& node, Canvas& x, const Canvas&);

}

#define CCV_STR(X) ((std::stringstream&)(std::stringstream() << X)).str()
#define CCV_C_STR(X) CCV_STR(X).c_str()

// doxygen markups below

namespace std {}

namespace cv {}

#endif // CANVAS_H