hdicoreRect.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_RECT__
#define __HDI_CORE_RECT__
 
#include "hdicorePoint.h"
#include "hdicoreSize.h"
 
namespace hdi
{
    #if defined(HDI_CORE_AIP_MODE)
        namespace aip
        {
            class Rect;
        }
    #elif defined(HDI_CORE_PSP_MODE)
        namespace psp
        {
            class Rect;
        }
    #endif
 
    namespace core
    {
        class Rect
        {
            public:
                Point origin;
 
                Size size;
 
                Rect();
 
                Rect(const double x_, const double y_, const double width_, const double height_);
 
                Rect(const Point& pt_, const Size& size_);
 
                Rect(const Rect& rect_);
            
                virtual ~Rect();
 
                virtual Rect& operator=(const Rect& rhs_);
                
                virtual bool operator==(const Rect& rhs_) const;
                
                virtual bool operator!=(const Rect& rhs_) const;
                
                virtual Rect operator+(const Rect& rhs_) const;
                
                virtual Rect& operator+=(const Rect& rhs_);
 
                virtual Rect operator-(const Rect& rhs_) const;
 
                virtual Rect& operator-=(const Rect& rhs_);
                
                virtual void offset(const double tx_, const double ty_);
 
                virtual void resize(const double w_, const double h_);
 
                virtual Rect inset(const double x_, const double y_) const;
 
                virtual Point topLeft() const;
 
                virtual Point topCenter() const;
 
                virtual Point topRight() const;
 
                virtual Point midLeft() const;
 
                virtual Point midCenter() const;
 
                virtual Point midRight() const;
 
                virtual Point bottomLeft() const;
 
                virtual Point bottomCenter() const;
 
                virtual Point bottomRight() const;
 
                virtual Point pointFromPinPoint(const BoundsPinPointType pinPt_) const;
 
                virtual double left() const;
 
                virtual double top() const;
 
                virtual double right() const;
 
                virtual double bottom() const;
 
                virtual void setLeft(const double left_);
 
                virtual void setTop(const double top_);
 
                virtual void setRight(const double right_);
 
                virtual void setBottom(const double bottom_);
 
                virtual double area() const;
 
                virtual double perimeter() const;
 
                virtual bool containsPoint(const Point& pt_) const;
 
                virtual bool overlaps(const Rect& rect2_) const;
 
                virtual bool enclosePoint(const Point& pt_);
 
                virtual Rect unionRects(const Rect& rect2_) const;
 
                virtual Rect scale(const double xScaler_, const double yScaler_) const;
 
                virtual bool intersection(const Rect& rect2_, Rect& iRect__) const;
 
                virtual void enclosingEllipse(double& width__, double& height__) const;
 
                virtual RectLineIntersectionType lineIntersectionPoints(
                    const Point& a_,
                    const Point& b_,
                    Point& iPt1__,
                    Point& iPt2__
                ) const;
 
                virtual RectLineIntersectionType lineIntersectionPoints(
                    const Point& a_,
                    const Point& b_,
                    const Angle& angle_,
                    Point& iPt1__,
                    Point& iPt2__
                ) const;
 
 
            private:
                #if defined(HDI_CORE_AIP_MODE)
                    friend aip::Rect* __accessImpl(const Rect&);
                    friend Rect __accessCtor(const aip::Rect&);
 
                    aip::Rect* __impl;
                    
                    Rect(const aip::Rect&);
                #elif defined(HDI_CORE_PSP_MODE)
                    friend psp::Rect* __accessImpl(const Rect&);
                    friend Rect __accessCtor(const psp::Rect&);
 
                    psp::Rect* __impl;
                    
                    Rect(const psp::Rect&);
                #endif
        };
        
        typedef std::unique_ptr<Rect> RectUP;
        typedef std::shared_ptr<Rect> RectSP;
        typedef std::weak_ptr<Rect> RectWP;
        
        #if defined(HDI_CORE_AIP_MODE)
            extern aip::Rect* __accessImpl(const Rect&);
            extern Rect __accessCtor(const aip::Rect&);
        #elif defined(HDI_CORE_PSP_MODE)
            extern psp::Rect* __accessImpl(const Rect&);
            extern Rect __accessCtor(const psp::Rect&);
        #endif
    }
}
 
#endif
// __HDI_CORE_RECT__