CRect.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// ICF 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