rectangle.h

 
#ifndef _aspose_system_drawing_rectangle_h_
#define _aspose_system_drawing_rectangle_h_
 
#include "fwd.h"
#include <system/object_ext.h>
#include <system/windows/forms/screen.h>
#include <system/string.h>
#include "drawing/size.h"
#include "drawing/point.h"
 
namespace System { namespace Drawing {
 
    class RectangleF;
    class ASPOSECPP_SHARED_CLASS Rectangle
    {
    private:
        friend class RectangleF;
 
        RTTI_INFO_VALUE_TYPE(Rectangle)
 
        public:
            ASPOSECPP_SHARED_API Rectangle();
            ASPOSECPP_SHARED_API Rectangle(int x, int y, int width, int height);
            ASPOSECPP_SHARED_API Rectangle(const Point & location, const Size & size);
            ASPOSECPP_SHARED_API Rectangle(const System::Windows::Forms::Screen::Rectangle_ & rect);
 
            inline static Rectangle FromLTRB(int left, int top, int right, int bottom) { return Rectangle(left, top, right - left, bottom - top); }
 
            inline Point get_Location() const { return Point(m_x, m_y); }
            inline void set_Location(Point value) { m_x = value.get_X(); m_y = value.get_Y(); }
 
            inline Size get_Size() const { return Size(m_width, m_height); }
            inline void set_Size(Size value) { m_width = value.get_Width(); m_height = value.get_Height(); }
 
            inline int get_X() const { return m_x; }
            inline void set_X(int value) { m_x = value; }
 
            inline int get_Y() const { return m_y; }
            inline void set_Y(int value) { m_y = value; }
 
            inline int get_Width() const { return m_width; }
            inline void set_Width(int value) { m_width = value; }
 
            inline int get_Height() const { return m_height; }
            inline void set_Height(int value) { m_height = value; }
 
            inline int get_Left() const { return m_x; }
            inline int get_Top() const { return m_y; }
            inline int get_Right() const { return (m_x + m_width); }
            inline int get_Bottom() const { return (m_y + m_height); }
            inline bool get_IsEmpty() const { return (m_x == 0 && m_y == 0 && m_width == 0 && m_height == 0); }
 
            ASPOSECPP_SHARED_API bool Equals(const Rectangle & rect) const;
 
            static ASPOSECPP_SHARED_API Rectangle Ceiling(const RectangleF & rect);
            static ASPOSECPP_SHARED_API Rectangle Truncate(const RectangleF & rect);
            static ASPOSECPP_SHARED_API Rectangle Round(const RectangleF & rect);
 
            ASPOSECPP_SHARED_API bool Contains(int x, int y) const;
            ASPOSECPP_SHARED_API bool Contains(const Point & point) const;
            ASPOSECPP_SHARED_API bool Contains(const Rectangle & rect) const;
 
            ASPOSECPP_SHARED_API void Inflate(int width, int height);
            ASPOSECPP_SHARED_API void Inflate(const Size & size);
 
            static ASPOSECPP_SHARED_API Rectangle Inflate(const Rectangle & rect, int x, int y);
 
            ASPOSECPP_SHARED_API void Intersect(const Rectangle & rect);
            static ASPOSECPP_SHARED_API Rectangle Intersect(const Rectangle & a, const Rectangle  & b);
            ASPOSECPP_SHARED_API bool IntersectsWith(const Rectangle & rect);
 
            static ASPOSECPP_SHARED_API Rectangle Union(const Rectangle & a, const Rectangle & b);
 
            ASPOSECPP_SHARED_API void Offset(const Point & pos);
            ASPOSECPP_SHARED_API void Offset(int x, int y);
 
            friend ASPOSECPP_SHARED_API bool operator==(const Rectangle & rect1, const Rectangle & rect2);
 
            friend ASPOSECPP_SHARED_API bool operator!=(const Rectangle & rect1, const Rectangle & rect2);
 
            bool operator == (std::nullptr_t) const { return false; }
            bool operator != (std::nullptr_t) const { return true; }
 
            ASPOSECPP_SHARED_API String ToString() const;
            ASPOSECPP_SHARED_API int GetHashCode() const;
 
            ASPOSECPP_SHARED_API operator RectangleF() const;
 
            static const ASPOSECPP_SHARED_API Rectangle Empty;
 
        private:
            int m_x;
            int m_y;
            int m_width;
            int m_height;
 
    };
 
    inline std::ostream& operator<<(std::ostream& stream, const Rectangle& rectangle)
    {
        stream << rectangle.ToString();
        return stream;
    }
 
    inline std::wostream& operator<<(std::wostream& stream, const Rectangle& rectangle)
    {
        stream << rectangle.ToString();
        return stream;
    }
 
}} // namespace System::Drawing
 
namespace System
{
 
    template<> struct IsBoxable<Drawing::Rectangle> : std::true_type {};
 
    template <>
    class BoxedValue<System::Drawing::Rectangle> : public DefaultBoxedValue<System::Drawing::Rectangle>
    {
    public:
        BoxedValue(const System::Drawing::Rectangle& value)
            : DefaultBoxedValue<System::Drawing::Rectangle>(value)
        {}
    };
 
}
 
#endif // _aspose_system_drawing_rectangle_h_