widget.h

#ifndef WIDGET_H
#define WIDGET_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 Layout;

class Widget
{
public:

    enum State
    {
        ENTER,  
        LEAVE,  
        PRESS,  
        RELEASE 
    };

    typedef std::function<void(Widget*)> CBWidget;

    typedef std::function<void(Widget*, State)> CBWidgetState;

    typedef std::function<void(Widget*, int)> CBUserSelection;

    Widget(const cv::Point &pos = cv::Point(0,0));

    virtual ~Widget();

    virtual const char *getType() const = 0;

    void notifyOnChange(CBWidgetState cb);

    cv::Scalar getOutlineColor() const;

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

    cv::Scalar getFillColor() const;

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

    bool getVisible() const
    {
        return visible;
    }

    virtual void setVisible(bool value);

    int getThickness() const;

    virtual void setThickness(int value);

    int getLineType() const;

    virtual void setLineType(int value);

    uchar getAlpha() const;

    void setAlpha(uchar value);

    enum Anchor
    {
        TOP    = 0b00000001,            
        BOTTOM = 0b00000010,            
        LEFT   = 0b00000100,            
        RIGHT  = 0b00001000,            
        CENTER = 0b00010000,            
        TOP_LEFT      = TOP | LEFT,     
        TOP_RIGHT     = TOP | RIGHT,    
        BOTTOM_LEFT   = BOTTOM | LEFT,  
        BOTTOM_RIGHT  = BOTTOM | RIGHT, 
        CENTER_TOP    = CENTER | TOP,   
        CENTER_BOTTOM = CENTER | BOTTOM,
        CENTER_LEFT   = CENTER | LEFT,  
        CENTER_RIGHT  = CENTER | RIGHT  
    };

    Anchor getLayoutAnchor() const
    {
        return layoutAnchor;
    }

    void setLayoutAnchor(const Anchor &value);

    Anchor getFlowAnchor() const
    {
        return flowAnchor;
    }

    void setFlowAnchor(const Anchor &value);

    int getId()
    {
        return id;
    }

    virtual const std::string &getStatusMsg() const;

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

    const cv::Point &getLocation() const;

    virtual void setLocation(const cv::Point &value);

    virtual void translate(const cv::Point &translation);

    bool getStretchX() const;

    void setStretchX(bool value);

    bool getStretchY() const;

    void setStretchY(bool value);

    cv::Scalar getSelectColor() const;

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

    std::shared_ptr<Widget> rmvFromLayout();

    enum Relief
    {
        FLAT,
        RAISED,
        SUNKEN,
        SELECTED
    };

    bool getIsSelectable() const;

    void setIsSelectable(bool value);

    int getForcedWidth() const;

    void setForcedWidth(int value);

    int getForcedHeight() const;

    void setForcedHeight(int value);

    void update();

    bool isRemoved() const;

    virtual const cv::Rect &getRect() = 0;

    bool getStretchXToParent() const;

    void setStretchXToParent(bool value);

    bool getStretchYToParent() const;

    void setStretchYToParent(bool value);

protected:

    virtual bool isCompoundWidget() const;

    void mergeMats(cv::Mat &roiSrc, cv::Mat &roiDst);

    void paintRelief();

    Relief getRelief() const;
    void setRelief(const Relief &value);

    cv::Rect getLayoutBoundaries() const;

    void setStateChangesBG();

    void allocateBG(const cv::Size &size);

    virtual void recalc() = 0;

    void flatWidget();

    void raisedWidget();

    void sunkenWidget();

    void selectedWidget();

    virtual void renderOn(cv::Mat &dst);

    virtual void drawFG(cv::Mat &dst) = 0;

    void callDrawFG(bool preAllocateMat=true);

    virtual const cv::Rect &getMinimalRect() = 0;


    /* TODO - write/read widgets to file for a designer app
    virtual void writeInternals(cv::FileStorage& fs) const = 0;
    virtual void readInternals(const cv::FileNode& node) = 0;
    */

    bool setDirty();

    bool getIsDirty() const;

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

    State getState() const;

    Layout* getLayout();

    int id;
    cv::Point location;
    cv::Scalar selectColor;
    Relief relief;
    bool visible;
    int thickness;
    int lineType;
    int forcedWidth;
    int forcedHeight;
    Anchor layoutAnchor;
    Anchor flowAnchor;
    bool stretchX;
    bool stretchY;
    bool stretchXToParent;
    bool stretchYToParent;
    bool isSelectable;
    std::string statusMsg;
    Layout *layout;

private:
    friend class Canvas;
    friend class CompoundWidget;

    // All the layout implementations are friends
    friend class LayoutBase;
    friend class AutoLayout;
    friend class VerticalLayout;
    friend class HorizontalLayout;

    virtual void mousePressed();

    virtual void mouseReleased();

    virtual void mouseEnter();

    virtual void mouseLeave();

    int genId();

    void setLayout(Layout &value);

    void layoutResized(const cv::Rect &);

    virtual void broadcastChange(State status);

    /* TODO - write/read widgets to file for a designer app
    friend void write(cv::FileStorage& fs, const std::string&, const Widget& x);
    friend void read(const cv::FileNode& node, Widget*& x, const Widget* default_value);

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

    cv::Scalar outlineColor;
    cv::Scalar fillColor;
    cv::Mat bg;
    cv::Mat fg;
    State state;
    bool isDirty;
    int updateCalls;
    std::list<CBWidgetState> changeNotifs;
};

/* TODO - write/read widgets to file for a designer app
// 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 Widget& x);
void read(const cv::FileNode& node, Widget*& x, const Widget* default_value);

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

}

#endif // WIDGET_H