CRect.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// ACF includes
#include <istd/CIndex2d.h>
#include <istd/TRange.h>
 
#include <i2d/CRectangle.h>
 
#include <ibase/CSize.h>
 
 
namespace i2d
{
 
 
class CRect
{
public:
       CRect();
       CRect(const CRect& rect);
       CRect(int left, int top, int right, int bottom);
       CRect(const istd::CIndex2d& leftTop, const istd::CIndex2d& rightBottom);
       CRect(const istd::CIndex2d& leftTop, const ibase::CSize& size);
       CRect(const i2d::CRectangle& rect);
       explicit CRect(const ibase::CSize& size);
 
       i2d::CRectangle GetRectangle() const;
 
       istd::CIndex2d GetLeftTop() const;
       void SetLeftTop(istd::CIndex2d position);
       istd::CIndex2d GetRightTop() const;
       void SetRightTop(istd::CIndex2d position);
       istd::CIndex2d GetLeftBottom() const;
       void SetLeftBottom(istd::CIndex2d position);
       istd::CIndex2d GetRightBottom() const;
       void SetRightBottom(istd::CIndex2d position);
 
       int GetLeft() const;
       void SetLeft(int left);
       int GetTop() const;
       void SetTop(int top);
       int GetRight() const;
       void SetRight(int right);
       int GetBottom() const;
       void SetBottom(int bottom);
 
       int GetWidth() const;
       int GetHeight() const;
 
       const istd::CIntRange& GetHorizontalRange() const;
       istd::CIntRange& GetHorizontalRangeRef();
       void SetHorizontalRange(const istd::CIntRange& range);
 
       const istd::CIntRange& GetVerticalRange() const;
       istd::CIntRange& GetVerticalRangeRef();
       void SetVerticalRange(const istd::CIntRange& range);
 
       istd::CIndex2d GetCenter() const;
 
       bool IsValid() const;
 
       bool IsEmpty() const;
 
       bool IsValidNonEmpty() const;
 
       bool IsNull() const;
 
       ibase::CSize GetSize() const;
 
       bool IsInside(const istd::CIndex2d& point) const;
 
       bool IsInside(const CRect& rect) const;
 
       bool IsOutside(const CRect& rect) const;
 
       void Reset();
 
       void Union(const CRect& rect);
 
       void GetUnion(const CRect& rect, CRect& result) const;
 
       CRect GetUnion(const CRect& rect) const;
 
       void Union(istd::CIndex2d point);
 
       CRect GetUnion(istd::CIndex2d point) const;
 
       void Expand(const CRect& rect);
 
       CRect GetExpanded(const CRect& rect) const;
 
       void Intersection(const CRect& rect);
 
       CRect GetIntersection(const CRect& rect) const;
 
       void Translate(istd::CIndex2d point);
 
       CRect GetTranslated(istd::CIndex2d point) const;
 
       // operators
       CRect& operator=(const CRect& rect);
       bool operator==(const CRect& rect) const;
       bool operator!=(const CRect& rect) const;
 
       // static methods
       static const i2d::CRect& GetEmpty();
       static const i2d::CRect& GetInvalid();
 
private:
       istd::CIntRange m_horizontalRange;
       istd::CIntRange m_verticalRange;
 
       // static atributes
       static CRect s_empty;
       static CRect s_invalid;
};
 
 
// inline methods
 
inline CRect::CRect()
{
#ifdef _DEBUG
       //     set to be invalid
       m_horizontalRange = istd::CIntRange::GetInvalid();
       m_verticalRange = istd::CIntRange::GetInvalid();
#endif //_DEBUG
}
 
 
inline CRect::CRect(const CRect& rect)
{
       *this = rect;
}
 
 
inline CRect::CRect(int left, int top, int right, int bottom)
{
       m_horizontalRange = istd::CIntRange(left, right);
       m_verticalRange = istd::CIntRange(top, bottom);
 
       Q_ASSERT(IsValid());
}
 
 
inline CRect::CRect(const istd::CIndex2d& leftTop, const istd::CIndex2d& rightBottom)
{
       m_horizontalRange = istd::CIntRange(leftTop.GetX(), rightBottom.GetX());
       m_verticalRange = istd::CIntRange(leftTop.GetY(), rightBottom.GetY());
 
       Q_ASSERT(IsValid());
}
 
 
inline CRect::CRect(const istd::CIndex2d& leftTop, const ibase::CSize& size)
{
       m_horizontalRange = istd::CIntRange(leftTop.GetX(), leftTop.GetX() + size.GetX());
       m_verticalRange = istd::CIntRange(leftTop.GetY(), leftTop.GetY() + size.GetY());
 
       Q_ASSERT(IsValid());
}
 
 
inline CRect::CRect(const i2d::CRectangle& rect)
{
       m_horizontalRange = istd::CIntRange(int(rect.GetLeft()), int(rect.GetRight()));
       m_verticalRange = istd::CIntRange(int(rect.GetTop()), int(rect.GetBottom()));
 
       Q_ASSERT(IsValid());
}
 
 
inline CRect::CRect(const ibase::CSize& size)
{
       m_horizontalRange = istd::CIntRange(0, size.GetX());
       m_verticalRange = istd::CIntRange(0, size.GetY());
 
       Q_ASSERT(IsValid());
}
 
 
inline i2d::CRectangle CRect::GetRectangle() const
{
       return i2d::CRectangle(
                            m_horizontalRange.GetMinValue(),
                            m_verticalRange.GetMinValue(),
                            m_horizontalRange.GetLength(),
                            m_verticalRange.GetLength());
}
 
 
inline istd::CIndex2d CRect::GetLeftTop() const
{
       return istd::CIndex2d(m_horizontalRange.GetMinValue(), m_verticalRange.GetMinValue());
}
 
 
inline void CRect::SetLeftTop(istd::CIndex2d position)
{
       m_horizontalRange.SetMinValue(position.GetX());
       m_verticalRange.SetMinValue(position.GetY());
}
 
 
inline istd::CIndex2d CRect::GetRightTop() const
{
       return istd::CIndex2d(m_horizontalRange.GetMaxValue(), m_verticalRange.GetMinValue());
}
 
 
inline void CRect::SetRightTop(istd::CIndex2d position)
{
       m_horizontalRange.SetMaxValue(position.GetX());
       m_verticalRange.SetMinValue(position.GetY());
}
 
 
inline istd::CIndex2d CRect::GetLeftBottom() const
{
       return istd::CIndex2d(m_horizontalRange.GetMinValue(), m_verticalRange.GetMaxValue());
}
 
 
inline void CRect::SetLeftBottom(istd::CIndex2d position)
{
       m_horizontalRange.SetMinValue(position.GetX());
       m_verticalRange.SetMaxValue(position.GetY());
}
 
 
inline istd::CIndex2d CRect::GetRightBottom() const
{
       return istd::CIndex2d(m_horizontalRange.GetMaxValue(), m_verticalRange.GetMaxValue());
}
 
 
inline void CRect::SetRightBottom(istd::CIndex2d position)
{
       m_horizontalRange.SetMaxValue(position.GetX());
       m_verticalRange.SetMaxValue(position.GetY());
}
 
 
inline int CRect::GetLeft() const
{
       return m_horizontalRange.GetMinValue();
}
 
inline void CRect::SetLeft(int left)
{
       m_horizontalRange.SetMinValue(left);
}
 
 
inline int CRect::GetTop() const
{
       return m_verticalRange.GetMinValue();
}
 
 
inline void CRect::SetTop(int top)
{
       return m_verticalRange.SetMinValue(top);
}
 
 
inline int CRect::GetRight() const
{
       return m_horizontalRange.GetMaxValue();
}
 
 
inline void CRect::SetRight(int right)
{
       return m_horizontalRange.SetMaxValue(right);
}
 
 
inline int CRect::GetBottom() const
{
       return m_verticalRange.GetMaxValue();
}
 
 
inline void CRect::SetBottom(int bottom)
{
       return m_verticalRange.SetMaxValue(bottom);
}
 
 
inline int CRect::GetWidth() const
{
       return m_horizontalRange.GetLength();
}
 
 
inline int CRect::GetHeight() const
{
       return m_verticalRange.GetLength();
}
 
 
inline const istd::CIntRange& CRect::GetHorizontalRange() const
{
       return m_horizontalRange;
}
 
 
inline istd::CIntRange& CRect::GetHorizontalRangeRef()
{
       return m_horizontalRange;
}
 
 
inline void CRect::SetHorizontalRange(const istd::CIntRange& range)
{
       m_horizontalRange = range;
}
 
 
inline const istd::CIntRange& CRect::GetVerticalRange() const
{
       return m_verticalRange;
}
 
 
inline istd::CIntRange& CRect::GetVerticalRangeRef()
{
       return m_verticalRange;
}
 
 
inline void CRect::SetVerticalRange(const istd::CIntRange& range)
{
       m_verticalRange = range;
}
 
 
inline istd::CIndex2d CRect::GetCenter() const
{
       return istd::CIndex2d(
                     m_horizontalRange.GetMinValue() + m_horizontalRange.GetLength() / 2,
                     m_verticalRange.GetMinValue() + m_verticalRange.GetLength() / 2);
}
 
 
inline bool CRect::IsValid() const
{
       return (m_horizontalRange.IsValid()) && (m_verticalRange.IsValid());
}
 
 
inline bool CRect::IsEmpty() const
{
       return (m_horizontalRange.IsEmpty()) || (m_verticalRange.IsEmpty());
}
 
 
inline bool CRect::IsValidNonEmpty() const
{
       return (m_horizontalRange.IsValidNonEmpty()) && (m_verticalRange.IsValidNonEmpty());
}
 
 
inline bool CRect::IsNull() const
{
       return (m_horizontalRange == istd::CIntRange::GetNull()) && (m_verticalRange == istd::CIntRange::GetNull());
}
 
 
inline ibase::CSize CRect::GetSize() const
{
       return ibase::CSize(m_horizontalRange.GetLength(), m_verticalRange.GetLength());
}
 
 
inline bool CRect::IsInside(const istd::CIndex2d& point) const
{
       Q_ASSERT(IsValid());
 
       return m_horizontalRange.Contains(point.GetX()) && m_verticalRange.Contains(point.GetY());
}
 
 
inline bool CRect::IsInside(const CRect& rect) const
{
       Q_ASSERT(IsValid());
       Q_ASSERT(rect.IsValid());
 
       if (rect.IsEmpty()){
              return true;
       }
       else{
              return m_horizontalRange.Contains(rect.m_horizontalRange) && m_verticalRange.Contains(rect.m_verticalRange);
       }
}
 
 
inline bool CRect::IsOutside(const CRect& rect) const
{
       Q_ASSERT(IsValid());
       Q_ASSERT(rect.IsValid());
 
       if (rect.IsEmpty()){
              return true;
       }
       else{
              return m_horizontalRange.IsOutsideOf(rect.m_horizontalRange) || m_verticalRange.IsOutsideOf(rect.m_verticalRange);
       }
}
 
 
inline void CRect::Reset()
{
       m_horizontalRange.Reset();
       m_verticalRange.Reset();
}
 
 
inline void CRect::Union(const CRect& rect)
{
       Q_ASSERT(rect.IsValid());
       Q_ASSERT(IsValid());
 
       if (IsEmpty()){
              *this = rect;
       }
       else if (!rect.IsEmpty()){
              m_horizontalRange.Unite(rect.m_horizontalRange);
              m_verticalRange.Unite(rect.m_verticalRange);
       }
}
 
 
inline void CRect::GetUnion(const CRect& rect, CRect& result) const
{
       Q_ASSERT(rect.IsValid());
       Q_ASSERT(IsValid());
 
       if (IsEmpty()){
              result = rect;
       }
       else if (!rect.IsEmpty()){
              result = *this;
 
              result.m_horizontalRange.Unite(rect.m_horizontalRange);
              result.m_verticalRange.Unite(rect.m_verticalRange);
       }
       else{
              result.Reset();
       }
}
 
 
inline CRect CRect::GetUnion(const CRect& rect) const
{
       Q_ASSERT(rect.IsValid());
       Q_ASSERT(IsValid());
 
       CRect result;
 
       GetUnion(rect, result);
 
       return result;
}
 
 
inline void CRect::Union(istd::CIndex2d point)
{
       Q_ASSERT(IsValid());
 
       int left = qMin(GetLeft(), point.GetX());
       int top = qMin(GetTop(), point.GetY());
       int right = qMax(GetRight(), point.GetX());
       int bottom = qMax(GetBottom(), point.GetY());
 
       m_horizontalRange = istd::CIntRange(left, right);
       m_verticalRange = istd::CIntRange(top, bottom);
}
 
 
inline CRect CRect::GetUnion(istd::CIndex2d point) const
{
       Q_ASSERT(IsValid());
 
       CRect result = *this;
 
       result.Union(point);
 
       return result;
}
 
 
inline void CRect::Expand(const CRect& rect)
{
       Q_ASSERT(rect.IsValid());
       Q_ASSERT(IsValid());
 
       m_horizontalRange.Expand(rect.m_horizontalRange);
       m_verticalRange.Expand(rect.m_verticalRange);
}
 
 
inline CRect CRect::GetExpanded(const CRect& rect) const
{
       Q_ASSERT(rect.IsValid());
       Q_ASSERT(IsValid());
 
       CRect result = *this;
 
       result.Expand(rect);
 
       return result;
}
 
 
inline void CRect::Intersection(const CRect& rect)
{
       Q_ASSERT(rect.IsValid());
       Q_ASSERT(IsValid());
 
       m_horizontalRange.Intersection(rect.m_horizontalRange);
       m_verticalRange.Intersection(rect.m_verticalRange);
 
       if (!m_horizontalRange.IsValid() || !m_verticalRange.IsValid()){
              Reset();
       }
}
 
 
inline CRect CRect::GetIntersection(const CRect& rect) const
{
       Q_ASSERT(rect.IsValid());
       Q_ASSERT(IsValid());
 
       CRect result = *this;
 
       result.Intersection(rect);
       
       return result;
}
 
 
inline void CRect::Translate(istd::CIndex2d point)
{
       m_horizontalRange.SetMinValue(m_horizontalRange.GetMinValue() + point.GetX());
       m_horizontalRange.SetMaxValue(m_horizontalRange.GetMaxValue() + point.GetX());
       m_verticalRange.SetMinValue(m_verticalRange.GetMinValue() + point.GetY());
       m_verticalRange.SetMaxValue(m_verticalRange.GetMaxValue() + point.GetY());
}
 
 
inline CRect CRect::GetTranslated(istd::CIndex2d point) const
{
       Q_ASSERT(IsValid());
 
       CRect result = *this;
 
       result.Translate(point);
 
       return result;
}
 
 
inline CRect& CRect::operator =(const CRect& rect)
{
       m_horizontalRange = rect.m_horizontalRange;
       m_verticalRange = rect.m_verticalRange;
 
       return *this;
}
 
 
inline bool CRect::operator==(const CRect& rect) const
{
       return (m_horizontalRange == rect.m_horizontalRange) && (m_verticalRange == rect.m_verticalRange);
}
 
 
inline bool CRect::operator!=(const CRect& rect) const
{
       return !operator==(rect);
}
 
 
// static methods
 
inline const i2d::CRect& CRect::GetEmpty()
{
       return s_empty;
}
 
 
inline const i2d::CRect& CRect::GetInvalid()
{
       return s_invalid;
}
 
 
} // namespace i2d