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_);
                #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__