point.h

 
#ifndef _aspose_system_drawing_point_h_
#define _aspose_system_drawing_point_h_
 
#include "fwd.h"
#include <system/string.h>
#include <system/boxed_value.h>
#include <functional>
 
namespace System { namespace Drawing {
    class ASPOSECPP_SHARED_CLASS Point
    {
        RTTI_INFO_VALUE_TYPE(Point)
        public:
            ASPOSECPP_SHARED_API Point();
            ASPOSECPP_SHARED_API Point(int x, int y);
            ASPOSECPP_SHARED_API Point(const Size& size);
            ASPOSECPP_SHARED_API Point(int dw);
 
            inline bool get_IsEmpty() const { return (m_x == 0 && m_y == 0); }
 
            inline int get_X() const { return m_x; }
            inline int get_Y() const { return m_y; }
 
            inline void set_X(int value) { m_x = value; }
            inline void set_Y(int value) { m_y = value; }
 
            ASPOSECPP_SHARED_API bool Equals(const Point& point) const;
 
            ASPOSECPP_SHARED_API int GetHashCode() const;
            ASPOSECPP_SHARED_API String ToString() const;
 
            static ASPOSECPP_SHARED_API Point Add(const Point& point, const Size& size);
            static ASPOSECPP_SHARED_API Point Subtract(const Point& point, const Size& size);
 
            static ASPOSECPP_SHARED_API Point Ceiling(const PointF& point);
            static ASPOSECPP_SHARED_API Point Truncate(const PointF& point);
            static ASPOSECPP_SHARED_API Point Round(const PointF& point);
 
            inline void Offset(int dx, int dy) { m_x += dx; m_y += dy; }
            inline void Offset(Point point) { Offset(point.m_x, point.m_y); }
 
            ASPOSECPP_SHARED_API operator PointF() const;
            ASPOSECPP_SHARED_API operator Size() const;
 
            friend ASPOSECPP_SHARED_API Point operator+(const Point& point, const Size& size);
            friend ASPOSECPP_SHARED_API Point operator-(const Point& point, const Size& size);
 
            friend ASPOSECPP_SHARED_API bool operator==(const Point& point1, const Point& point2);
            friend ASPOSECPP_SHARED_API bool operator!=(const Point& point1, const Point& point2);
            friend ASPOSECPP_SHARED_API bool operator<(const Point& point1, const Point& point2);
 
            static const ASPOSECPP_SHARED_API Point Empty;
 
            bool IsNull() const { return false; }
            size_t getStdHash() const;
 
        private:
            inline int hi_word(int n) { return ((n >> 16) & 0xffff); }
            inline int lo_word(int n) { return (n & 0xffff); }
 
            int m_x;
            int m_y;
 
    };
 
    inline std::ostream& operator<<(std::ostream& stream, const Point& point)
    {
        stream << point.ToString();
        return stream;
    }
 
    inline std::wostream& operator<<(std::wostream& stream, const Point& point)
    {
        stream << point.ToString();
        return stream;
    }
 
}} // namespace System::Drawing
 
namespace System
{
 
    template<> struct IsBoxable<Drawing::Point> : std::true_type {};
 
    template <>
    class BoxedValue<System::Drawing::Point> : public DefaultBoxedValue<System::Drawing::Point>
    {
    public:
        BoxedValue(const System::Drawing::Point& value)
            : DefaultBoxedValue<System::Drawing::Point>(value)
        {}
    };
 
}
namespace std
{
    template<> struct hash<System::Drawing::Point>
    {
        inline size_t operator()(System::Drawing::Point const& p) const
        {
            return p.getStdHash();
        }
    };
}
 
#endif // _aspose_system_drawing_point_h_