hdicoreCustomWidget.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_CUSTOM_WIDGET__
#define __HDI_CORE_CUSTOM_WIDGET__
 
#include <vector>
 
#include "hdicoreColor.h"
#include "hdicoreWidget.h"
 
namespace hdi
{
    namespace core
    {
        class Callback;
        class Font;
        
        #if defined(HDI_CORE_AIP_MODE)
            class Panel;
        #endif
        
        #if defined(HDI_CORE_PSP_MODE)
            class PixelMap;
        #endif
        
        class CustomWidget : public Widget
        {
            public:
                typedef std::vector<Point> PointVector;
            
                CustomWidget();

                CustomWidget(const CustomWidget& widget_);

                CustomWidget(const Rect& frame_);
                
                virtual ~CustomWidget();

                virtual CustomWidget& operator=(const CustomWidget& rhs_);
                
                virtual CustomWidget* clone() const;
                
                virtual CustomWidget* duplicate() const;

                virtual void redraw();

                virtual ModifierKey getClickDragModifiers() const;
                
                virtual bool getClickDragLocations(Point& start__, Point& end__) const;
            
                #if defined(HDI_CORE_PSP_MODE)
                    virtual bool getScrollDeltas(double& dx__, double& dy__) const;
                #endif
                // HDI_CORE_PSP_MODE

                virtual bool isMouseOver() const;

                virtual Callback* const mouseOverCallback() const;

                virtual void setMouseOverCallback(const Callback& cb_);

                virtual Callback* const mouseMoveCallback() const;

                virtual void setMouseMoveCallback(const Callback& cb_);

                virtual Callback* const mouseOutCallback() const;

                virtual void setMouseOutCallback(const Callback& cb_);

                virtual bool focusesOnClick() const;

                virtual void setFocusesOnClick(const bool focus_);

                virtual Callback* const mouseDownCallback() const;

                virtual void setMouseDownCallback(const Callback& cb_);

                virtual Callback* const mouseDragCallback() const;

                virtual void setMouseDragCallback(const Callback& cb_);

                virtual Callback* const mouseUpCallback() const;

                virtual void setMouseUpCallback(const Callback& cb_);
            
                #if defined(HDI_CORE_PSP_MODE)
                    virtual Callback* const scrollCallback() const;
            
                    virtual void setScrollCallback(const Callback& cb_);
                #endif
                // HDI_CORE_PSP_MODE
            
                virtual bool draggable() const;
            
                virtual void setDraggable(const bool enable_);
            
                virtual std::string dragData() const;
            
                virtual void setDragData(const std::string& data_);
            
                virtual bool droppable() const;
            
                virtual void setDroppable(const bool enable_);
            
                virtual Callback* const potentialDropCallback() const;
            
                virtual void setPotentialDropCallback(const Callback& callback_);
            
                virtual Point potentialDropPoint() const;
            
                virtual Callback* const dropCallback() const;
            
                virtual void setDropCallback(const Callback& callback_);
            
                virtual std::string droppedData() const;
            
                virtual Point droppedPoint() const;
            
                #if defined(HDI_CORE_AIP_MODE)
                    virtual std::unique_ptr<Panel> linkedPanel() const;
            
                    virtual void setLinkedPanel(const Panel& p_);
            
                    virtual void removeLinkedPanel();
            
                    virtual void showLinkedPanel(const Point& pt_, const Widget* const focus_);
            
                    virtual void hideLinkedPanel();
                #endif

                virtual PlatformDrawingContextPtr platformDC() const;

                virtual Callback* const drawCallback() const;

                virtual void setDrawCallback(const Callback& cb_);

                virtual bool clearsOnRedraw() const;

                virtual void setClearsOnRedraw(const bool clear_);
                
                virtual void setDrawColor(const Color& color_);

                virtual void drawLine(const Point& from_, const Point& to_);

                virtual void drawRect(const Rect& rect_, const bool fill_ = false);

                virtual void drawRoundedRect(const Rect& rect_, const double radius_, const bool fill_ = false);

                virtual void drawEllipse(const Rect& rect_, const bool fill_ = false);

                virtual void drawPolygon(const PointVector& points_, const bool fill_ = false);
            
                virtual void drawImage(const Point& tl_, const int16_t pngID_, const double scale_ = 1.0);
            
                virtual void drawText(
                    const Point& tl_,
                    const std::string& text_,
                    const Font& font_,
                    const double fontSize_
                );
            
                #if defined(HDI_CORE_PSP_MODE)
                    virtual void drawPixelData(
                        const PixelMap& srcPM_,
                        const Rect& srcArea_,
                        const Point& dstTL_,
                        const Rect& dstArea_
                    );
                #endif
                // HDI_CORE_PSP_MODE
        };
        
        typedef std::unique_ptr<CustomWidget> CustomWidgetUP;
        typedef std::shared_ptr<CustomWidget> CustomWidgetSP;
        typedef std::weak_ptr<CustomWidget> CustomWidgetWP;
    }
}
 
#endif
// __HDI_CORE_CUSTOM_WIDGET__