cRectI.h

Go to the documentation of this file.

//
 
#ifndef _INC_cRectI_H
#define _INC_cRectI_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cRectT.h"
#include "cPoint2.h"
#include "../WinAPI/WinTypes.h"
#include "GrayCore/include/cString.h"
 
namespace GrayLib
{
        class cVariant;
 
        class GRAYLIB_LINK cRectI : public cRectNT<int>
        {
 
                typedef cRectNT<int> SUPER_t;
 
        public:
                cRectI() noexcept
                {
                        // ASSUME DVALUE_t = int
                }
                cRectI(DVALUE_t nleft, DVALUE_t ntop, DVALUE_t nright = 0, DVALUE_t nbottom = 0)
                        : cRectNT<DVALUE_t>(nleft, ntop, nright, nbottom)
                {
                        // NormalizeRect(); //?
                }
 
#ifdef _WIN32
                // Cast directly to the windows type.
                cRectI(const RECT& rect)
                        : cRectNT<DVALUE_t>(*((const SUPER_t*)&rect))
                {}
                inline operator RECT&() noexcept
                {
                        return *((RECT*)this);
                }
                inline operator const RECT&() const noexcept
                {
                        return *((const RECT*)this);
                }
                inline operator RECT*() noexcept
                {
                        return (RECT*) this;
                }
                inline operator const RECT*() const noexcept
                {
                        return (const RECT*) this;
                }
#endif
 
                bool IsInsideX(DVALUE_t x) const noexcept
                {
                        return(x >= left && x < right);
                }
                bool IsInsideY(DVALUE_t y) const noexcept
                {
                        return(y >= top && y < bottom);
                }
                bool PtInRect(DVALUE_t x, DVALUE_t y) const noexcept
                {
                        return(IsInsideX(x) && IsInsideY(y));
                }
                bool PtInRect(const cPoint2i& pt) const noexcept
                {
                        return PtInRect(pt.x, pt.y);
                }
                bool ClampPtInRectX(cPoint2i& pt) const noexcept
                {
                        bool bChange = false;
                        // x
                        if (pt.x < left)
                        {
                                pt.x = left;
                                bChange = true;
                        }
                        if (pt.x >= right)
                        {
                                pt.x = right - 1;
                                bChange = true;
                        }
                        // y
                        if (pt.y < top)
                        {
                                pt.y = top;
                                bChange = true;
                        }
                        if (pt.y >= bottom)
                        {
                                pt.y = bottom - 1;
                                bChange = true;
                        }
                        return bChange;
                }
                bool IsInsideMe(const cRectI& rect) const noexcept
                {
                        if (rect.left < left)
                                return false;
                        if (rect.top < top)
                                return false;
                        if (rect.right > right)
                                return false;
                        if (rect.bottom > bottom)
                                return false;
                        return true;
                }
 
                DVALUE_t GetOverlapX(const cRectI& rect) const noexcept
                {
                        DVALUE_t iLeft2 = MAX(this->left, rect.left);
                        DVALUE_t iRight2 = MIN(this->right, rect.right);
                        // if (iLeft2 > iRight2) then the two rectangles do not overlap.
                        return iRight2 - iLeft2;
                }
                DVALUE_t GetOverlapY(const cRectI& rect) const noexcept
                {
                        DVALUE_t iTop2 = MAX(this->top, rect.top);
                        DVALUE_t iBottom2 = MIN(this->bottom, rect.bottom);
                        // if (iTop2 > iBottom2) then the two rectangles do not overlap.
                        return iBottom2 - iTop2;
                }
                bool IsOverlapped(const cRectI& r, DVALUE_t minx, DVALUE_t miny) const noexcept
                {
                        return(GetOverlapX(r) >= minx && GetOverlapY(r) >= miny);
                }
                bool IsOverlapped(const cRectI& rect) const noexcept
                {
                        if (rect.left >= right)
                                return false;
                        if (rect.top >= bottom)
                                return false;
                        if (rect.right <= left)
                                return false;
                        if (rect.bottom <= top)
                                return false;
                        return true;
                }
 
                bool ClampPtInRectI(cPoint2f& pt) const
                {
                        bool bChange = false;
                        // x
                        if (pt.x < left)
                        {
                                pt.x = (float)left;
                                bChange = true;
                        }
                        if (pt.x > right)
                        {
                                pt.x = (float)right;
                                bChange = true;
                        }
                        // y
                        if (pt.y < top)
                        {
                                pt.y = (float)top;
                                bChange = true;
                        }
                        if (pt.y > bottom)
                        {
                                pt.y = (float)bottom;
                                bChange = true;
                        }
                        return bChange;
                }
 
                void UnionPoint(DVALUE_t x, DVALUE_t y)
                {
                        if (x < left)
                                left = x;
                        if (y < top)
                                top = y;
                        if (x >= right)
                                right = x + 1;
                        if (y >= bottom)
                                bottom = y + 1;
                }
 
                void OffsetPositive()
                {
                        NormalizeRect();
                        if (left < 0)
                                OffsetRectX(-left);
                        if (top < 0)
                                OffsetRectY(-top);
                }
 
                void SnapToGrid(DVALUE_t iSizeXY) noexcept
                {
                        iSizeXY--;
                        left &= ~iSizeXY;
                        right = (right | iSizeXY) + 1;
                        top &= ~iSizeXY;
                        bottom = (bottom | iSizeXY) + 1;
                }
 
                cPoint2i GetRectCorner(DIR_TYPE eDir) const;
                cWinSize get_RectSize() const noexcept
                {
                        return cWinSize(Width(), Height());
                }
 
                ITERATE_t SetRectStr(const GChar_t* pszVal, bool bSizes = false);
                cString get_RectStr(void) const;
 
                ITERATE_t v_SetRect(const cVariant& vVal, ITERATE_t i = 0);
                void v_GetRect(cVariant& vVal) const;
        };
 
        //**************************************************************
 
#if ! defined(_MFC_VER) // && !defined(__ATLTYPES_H__)
        typedef cRectI CRect;   
#endif // ! _MFC_VER
 
#ifdef _WIN32
        // convert windows native types to Gray types.
        inline cRectI& Cvt(RECT& pt)
        {
                return *((cRectI*)&pt);
        }
        inline const cRectI& Cvt(const RECT& pt)
        {
                return *((const cRectI*)&pt);
        }
#endif
}
 
#endif // _INC_cRectI_H