cRegion.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cRegion_H
#define _INC_cRegion_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cRectI.h"
#include "GrayCore/include/cArray.h"
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
namespace Gray
{
        template class GRAYLIB_LINK CArray<GrayLib::cRectI, const GrayLib::cRectI&>;
        template class GRAYLIB_LINK cArrayTyped<GrayLib::cRectI, const GrayLib::cRectI&>;
}
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cRegion);
 
        class GRAYLIB_LINK cRegion : public CObject // similar to MFC CRgn
        {
                typedef int DVALUE_t;   
 
        protected:
                cRectI m_rectUnion;             
        private:
                cArrayStruct<cRectI> m_Rects; 
 
        private:
                void UpdateRegionUnion();
 
        public:
                cRegion(const cRectI& rect);
                cRegion();
                virtual ~cRegion();
 
                virtual bool isValidCheck() const noexcept // override // memory allocation and structure definitions are valid.
                {
                        if (!COBJECT_IsValidCheck())
                                return false;
                        if (!IS_TYPE_OF(cRegion, this)) // structure definitions are valid.
                                return false;
                        return true;
                }
 
                bool isRegionEmpty() const
                {
                        return(m_rectUnion.IsRectEmpty());
                }
                void EmptyRegion()
                {
                        m_rectUnion.SetRectEmptyX();
                        m_Rects.RemoveAll();
                }
                void AddRegion(const cRegion* pRegionTest);
                bool SubtractRegion(const cRegion* pRegionTest);
                void SetRegionSubtract(const cRectI& rect1, const cRectI& rect2);
 
                const cRectI& get_RectUnion() const
                {
                        return m_rectUnion;
                }
                void put_RectUnion(const cRectI& rect)
                {
                        m_Rects.RemoveAll();
                        m_rectUnion = rect;
                }
 
                ITERATE_t get_RegionRectCount() const;
                const cRectI& GetRegionRect(ITERATE_t i) const;
                cRectI& RefRegionRect(ITERATE_t i);
                virtual bool AddRegionRect(const cRectI& rect);
                virtual void RemoveRegionRect(ITERATE_t i);
                bool SubtractRegionRect(const cRectI& rect);
 
                void OptimizeRegionRects();
 
                cPoint2i GetRegionCorner(DIR_TYPE eDir = DIR_QTY) const;
                bool PtInRegion(int x, int y) const;    // MFC like
                bool PtInRegion(const cPoint2i& pt) const       // MFC like
                {
                        return PtInRegion(pt.x, pt.y);
                }
 
                // RectInRegion = really just checks overlap!
                bool IsOverlapped(const cRectI& rect) const;
                bool IsInsideMe(const cRectI& rect) const;
 
                bool IsInsideMe(const cRegion* pRegionIsSmaller) const;
                bool IsOverlapped(const cRegion* pRegionTest) const;
                bool IsEqualRegion(const cRegion* pRegionTest) const;
 
                HRESULT v_SetRegion(const cVariant& vVal);
                void v_GetRegion(cVariant& vVal) const;
 
                UNITTEST_FRIEND(cRegion);
        };
}
 
#endif // _INC_cRegion_H