CRectangle.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
 
 
// Qt includes
#include <QtCore/QRectF>
 
// ACF includes
#include <istd/TRange.h>
#include <istd/CIndex2d.h>
#include <iser/ISerializable.h>
#include <i2d/CObject2dBase.h>
 
 
namespace i2d
{
 
 
class CRect;
class CLine2d;
 
 
class CRectangle: public CObject2dBase
{
public:
       static QByteArray GetTypeName();
 
       CRectangle();
       CRectangle(double left, double top, double width, double height);
       CRectangle(const CVector2d& topLeft, const CVector2d& bottomRight);
       CRectangle(const istd::CRange& horizontalRange, const istd::CRange& verticalRange);
       CRectangle(const i2d::CRect& rect);
       explicit CRectangle(const istd::CIndex2d& size);
 
       bool IsValid() const;
 
       bool IsEmpty() const;
 
       bool IsValidNonEmpty() const;
 
       void Reset();
 
       double GetLeft() const;
       void SetLeft(double left);
       double GetTop() const;
       void SetTop(double top);
       double GetRight() const;
       void SetRight(double right);
       double GetBottom() const;
       void SetBottom(double bottom);
 
       const istd::CRange& GetHorizontalRange() const;
       istd::CRange& GetHorizontalRangeRef();
       void SetHorizontalRange(const istd::CRange& range);
 
       const istd::CRange& GetVerticalRange() const;
       istd::CRange& GetVerticalRangeRef();
       void SetVerticalRange(const istd::CRange& range);
 
       CVector2d GetLeftTop() const;
       void SetTopLeft(const CVector2d& topLeft);
       CVector2d GetRightTop() const;
       void SetTopRight(const CVector2d& topRight);
       CVector2d GetLeftBottom() const;
       void SetBottomLeft(const CVector2d& bottomLeft);
       CVector2d GetRightBottom() const;
       void SetBottomRight(const CVector2d& bottomRight);
 
       CVector2d GetLeftCenter() const;
       CVector2d GetRightCenter() const;
       CVector2d GetTopCenter() const;
       CVector2d GetBottomCenter() const;
 
       bool Contains(const CVector2d& point) const;
       bool Contains(const istd::CIndex2d& point) const;
       bool Contains(const CRectangle& rect) const;
 
       double GetWidth() const;
       double GetHeight() const;
 
       CVector2d GetSize() const;
 
       bool IsIntersectedBy(const CRectangle& rect) const;            
 
       bool IsIntersectedBy(const CLine2d& line) const;
 
       CRectangle GetIntersection(const CRectangle& rect) const;
 
       CLine2d GetIntersection(const CLine2d& line) const;
 
       void Intersect(const CRectangle& rectangle);
 
       CRectangle GetUnion(const CRectangle& rect) const;
       void Unite(const CRectangle& rect);
 
       CRectangle GetUnion(const i2d::CVector2d& position) const;
       void Unite(const i2d::CVector2d& position);
 
       CRectangle GetExpanded(const CRectangle& rect) const;
       void Expand(const CRectangle& rect);
 
       double GetDistance(const CVector2d& position) const;
 
       double GetMaxDistance(const CVector2d& position) const;
 
       CVector2d GetNearestPointTo(const CVector2d& point) const;
 
       void Translate(const i2d::CVector2d& delta); 
       CRectangle GetTranslated(const i2d::CVector2d& delta) const;
       
       bool operator==(const CRectangle& rect) const;
       bool operator!=(const CRectangle& rect) const;
 
       operator QRectF() const;
 
       // reimplemented (i2d::IObject2d)
       virtual CVector2d GetCenter() const override;
       virtual void MoveCenterTo(const CVector2d& position) override;
       virtual CRectangle GetBoundingBox() const override;
       virtual bool Transform(
                            const ITransformation2d& transformation,
                            ITransformation2d::ExactnessMode mode = ITransformation2d::EM_NONE,
                            double* errorFactorPtr = NULL) override;
       virtual bool InvTransform(
                            const ITransformation2d& transformation,
                            ITransformation2d::ExactnessMode mode = ITransformation2d::EM_NONE,
                            double* errorFactorPtr = NULL) override;
       virtual bool GetTransformed(
                            const ITransformation2d& transformation,
                            IObject2d& result,
                            ITransformation2d::ExactnessMode mode = ITransformation2d::EM_NONE,
                            double* errorFactorPtr = NULL) const override;
       virtual bool GetInvTransformed(
                            const ITransformation2d& transformation,
                            IObject2d& result,
                            ITransformation2d::ExactnessMode mode = ITransformation2d::EM_NONE,
                            double* errorFactorPtr = NULL) const override;
 
       // reimplemented (iser::IObject)
       virtual QByteArray GetFactoryId() const override;
       
       // reimplemented (iser::ISerializable)
       virtual bool Serialize(iser::IArchive& archive) override;
 
       // reimplemented (istd::IChangeable)
       virtual int GetSupportedOperations() const override;
       virtual bool CopyFrom(const IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
       virtual istd::TUniqueInterfacePtr<istd::IChangeable> CloneMe(CompatibilityMode mode = CM_WITHOUT_REFS) const override;
 
       // static methods
       static const i2d::CRectangle& GetEmpty();
       static const i2d::CRectangle& GetInvalid();
 
private:
       istd::CRange m_horizontalRange;
       istd::CRange m_verticalRange;
 
       // static atributes
       static CRectangle s_empty;
       static CRectangle s_invalid;
};
 
 
// inline methods
 
inline double CRectangle::GetLeft() const
{
       return m_horizontalRange.GetMinValue();
}
 
 
inline double CRectangle::GetTop() const
{
       return m_verticalRange.GetMinValue();
}
 
 
inline double CRectangle::GetRight() const
{
       return m_horizontalRange.GetMaxValue();
}
 
 
inline double CRectangle::GetBottom() const
{
       return m_verticalRange.GetMaxValue();
}
 
 
inline const istd::CRange& CRectangle::GetHorizontalRange() const
{
       return m_horizontalRange;
}
 
 
inline istd::CRange& CRectangle::GetHorizontalRangeRef()
{
       return m_horizontalRange;
}
 
 
inline const istd::CRange& CRectangle::GetVerticalRange() const
{
       return m_verticalRange;
}
 
 
inline istd::CRange& CRectangle::GetVerticalRangeRef()
{
       return m_verticalRange;
}
 
 
// static methods
 
inline const i2d::CRectangle& CRectangle::GetEmpty()
{
       return s_empty;
}
 
 
inline const i2d::CRectangle& CRectangle::GetInvalid()
{
       return s_invalid;
}
 
 
} // namespace i2d