PMRect.h

//========================================================================================
// 
// $File$
// 
// Owner: Lonnie Millett
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __PMRECT__
#define __PMRECT__

#include "PMReal.h"
#include "PMPoint.h"

//----------------------------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------------------------
class PMRect;
class IPMStream;
class PMMatrix;
namespace dvacore {
 namespace geom {
 template <class T> class RectT;
 }
}

//----------------------------------------------------------------------------------------
// Typedefs
// The following types are designed primarily for use in parameter lists to aid in
// determining what coordinate space a method or function expects a parameter to be in.
// They are just synonyms for PMRect
//----------------------------------------------------------------------------------------
typedef PMRect PBPMRect; // rect in "Pasteboard" coordinates
typedef PMRect IPMRect; // rect in "Inner" coordinates of page item
typedef K2Vector<PMRect> PMRectCollection;

#ifdef PUBLIC_BUILD
#endif

extern const PMRect kEmptyRect;


 SysRect ToSys(const PMRect& r); 
 bool16 Intersect(const PMRect& r1, const PMRect& r2);
 bool16 Intersect(const PMRect& r1, const PMMatrix& r1_to_r2_xform, const PMRect& r2);
 PMRect MakeIntersect(const PMRect& r1, const PMMatrix& r1_to_r2_xform, const PMRect& r2);
 bool16 IntersectOrAbut(const PMRect& r1, const PMRect& r2);
 bool16 IntersectOrAbut(const PMRect& r1, const PMMatrix& r1_to_r2_xform, const PMRect& r2);
 PMRect MakeIntersectOrAbut(const PMRect& r1, const PMMatrix& r1_to_r2_xform, const PMRect& r2);
 PMRect Intersection(const PMRect& r1, const PMRect& r2, const PMRect& emptyRect = kEmptyRect);
 PMRect IntersectionOrAbut(const PMRect& r1, const PMRect& r2, const PMRect& emptyRect = kEmptyRect);
 PMRect Union(const PMRect& r1, const PMRect& r2);
 bool16 UnionIsRect(const PMRect& r1, const PMRect& r2);
//find a rectangle of greatest area centered and contained within the parallelogram formed by transforming rectangle r with matrix m.
 PMRect MaximalInscribedRectangle( const PMRect& r, const PMMatrix& m);
//return the area of r2 contained in the parallelogram you get when r1 is transformed by r1_to_r2_xform
 PMReal IntersectionArea( const PMRect& r1, const PMMatrix& r1_to_r2_xform, const PMRect& r2);

//----------------------------------------------------------------------------------------
// PMRect
//----------------------------------------------------------------------------------------

class PMRect
{
 public:
 typedef base_type data_type;
 
 enum PointIndex {
 kInvalidPoint = -1,
 kFirstPoint = 0,
 
 kMiddleTop = 0,
 kLeftMiddle = 1,
 kMiddleBottom = 2,
 kRightMiddle = 3,
 
 kLeftTop = 4,
 kRightTop = 5,
 kRightBottom = 6,
 kLeftBottom = 7,
 
 kCenter = 8,
 
 kLastPoint = kCenter
 }; 
 
 constexpr PMRect() noexcept : left(0.0), top(0.0), right(0.0), bottom(0.0)
 {
 }
 
 explicit PMRect(const PMPoint& point) noexcept;
 
 PMRect(const PMPoint& one_corner, const PMPoint& opposing_corner) noexcept;
 
 PMRect(const PMReal& l, const PMReal& t, const PMReal& r, const PMReal& b) noexcept;
 
 PMRect(const SysRect& r) noexcept;


 explicit PMRect( const dvacore::geom::RectT<float>& r) noexcept;


#if MACINTOSH //on Windows, an Int32Rect is a SysRect

 explicit PMRect( const Int32Rect& r) noexcept;
#endif

 constexpr PMRect(const PMRect &) noexcept = default;
 constexpr PMRect(PMRect &&) noexcept = default;
 PMRect &operator =(const PMRect &) noexcept = default;
 PMRect &operator =(PMRect &&) noexcept = default;
 
 // Outbound Conversions
 
 friend SysRect ToSys(const PMRect& r); 

 friend dvacore::geom::RectT<float> ToRectF32_(const PMRect& r);


 friend Int32Rect ToInt32Rect_(const PMRect& r);


 // Query Methods
 
 bool16 IsEmpty() const noexcept;
 
 bool16 IsCorner(PointIndex whichPoint) const noexcept;
 
 bool16 IsMiddle(PointIndex whichPoint) const noexcept;

 bool16 PointIn(const PMPoint& pt) const noexcept;

 bool16 ContainsPoint(const PMPoint& pt) const noexcept;
 
 bool16 RectIn(const PMRect& r) const noexcept;

 bool16 ContainsRect( const PMRect& r) const noexcept;

 bool16 ContainsRect( const PMRect& r, const PMMatrix& r_to_this_xform) const;
 
 PMReal AspectRatio() const;
 
 PMReal DistanceTo(const PMPoint& pt) const;
 
 friend bool16 Intersect(const PMRect& r1, const PMRect& r2);
 friend bool16 Intersect_exact( const PMRect&r1, const PMRect& r2);
 friend bool16 Intersect(const PMRect& r1, const PMMatrix& xform, const PMRect& r2);
 friend PMRect MakeIntersect(const PMRect& r1, const PMMatrix& xform, const PMRect& r2);

 friend bool16 IntersectOrAbut(const PMRect& r1, const PMRect& r2);
 friend bool16 IntersectOrAbut_exact(const PMRect&r1, const PMRect& r2);
 friend bool16 IntersectOrAbut(const PMRect& r1, const PMMatrix& xform, const PMRect& r2);
 friend PMRect MakeIntersectOrAbut(const PMRect& r1, const PMMatrix& xform, const PMRect& r2);
 
 friend PMRect Intersection(const PMRect& r1, const PMRect& r2, const PMRect& emptyRect);

 friend PMRect IntersectionOrAbut(const PMRect& r1, const PMRect& r2, const PMRect& emptyRect);

 // Accessor Methods
 
 const PMReal& Left() const noexcept;
 
 PMReal& Left() noexcept;

 void Left(const PMReal& c) noexcept;
 
 const PMReal& Top() const noexcept;

 PMReal& Top() noexcept;

 void Top(const PMReal& c) noexcept;
 
 const PMReal& Right() const noexcept;

 PMReal& Right() noexcept;

 void Right(const PMReal& c) noexcept;
 
 const PMReal& Bottom() const noexcept;

 PMReal& Bottom() noexcept;

 void Bottom(const PMReal& c) noexcept;
 
 PMPoint LeftTop(void) const noexcept;

 void LeftTop(const PMPoint& pt) noexcept;
 
 PMPoint RightBottom(void) const noexcept;

 void RightBottom(const PMPoint& pt) noexcept;
 
 PMPoint RightTop(void) const noexcept;

 void RightTop(const PMPoint& pt) noexcept;
 
 PMPoint LeftBottom(void) const noexcept;

 void LeftBottom(const PMPoint& pt) noexcept;
 
 PMReal Height() const noexcept;

 PMReal Width() const noexcept;

 PMPoint Dimensions() const noexcept;
 
 void SetHeight(const PMReal& height);
 
 void SetWidth(const PMReal& width);

 void SetDimensions(const PMReal& width, const PMReal& height);
 
 PMReal GetHCenter() const;

 PMReal GetVCenter() const;

 PMPoint GetCenter() const;
 
 PMPoint GetPoint(PointIndex whichPoint) const;
 
 PointIndex GetPointIndex(const PMPoint& aPoint) const;
 
 PMPoint GetOppositePoint(PointIndex whichPoint) const;
 
 PointIndex GetOppositePointIndex(PointIndex whichPoint) const;
 
 // Manipulation Methods
 
 PMRect& SetEmpty() noexcept;
 
 bool16 Normalize() noexcept;
 
 PMRect& Round();
 
 PointIndex MovePointTo(PointIndex whichPoint, const PMPoint& toPt);

 PMRect& MoveRel(const PMReal& dx, const PMReal& dy);
 PMRect& MoveRel(const PMPoint& point);
 PMRect& MoveTo(const PMReal& dx, const PMReal& dy);
 PMRect& MoveTo(const PMPoint& point);
 PMRect& CenterOn(const PMReal& dx, const PMReal& dy);
 PMRect& CenterOn(const PMPoint& point);
 
 PMRect& Inset(const PMReal& dx, const PMReal& dy);
 
 bool16 ConstrainTo(PMRect& constrainedRect);
 
 void Union (const PMRect& rhs);
 
 void Expand (const PMPoint& pt);
 
 friend PMRect Union(const PMRect& r1, const PMRect& r2);
 friend bool16 UnionIsRect(const PMRect& r1, const PMRect& r2);
 
 // Comparison Operators
 
 friend bool16 operator ==(const PMRect& a, const PMRect& b) noexcept;
 
 friend bool16 operator !=(const PMRect& a, const PMRect& b) noexcept;

 // Utility functions
 
 static int32 PointIndexToIndex (PMRect::PointIndex ptIndex);

 static PMRect::PointIndex IndexToPointIndex (int32 index);
 
 // Streaming
 
 void ReadWrite (IPMStream* iPMStream);
 
// VC6 compiler error, CWE
#if (_MSC_VER >= 1200) // VC6 or greater
 public:
#else
 private:
#endif
 PMReal left;
 PMReal top;
 PMReal right;
 PMReal bottom;
 friend bool16 Intersect_( const PMRect& r1, const PMMatrix& r1_to_r2_xform, const PMRect& r2, PMPoint* p);
 friend bool16 IntersectOrAbut_( const PMRect& r1, const PMMatrix& r1_to_r2_xform, const PMRect& r2, PMPoint* p);

};



//----------------------------------------------------------------------------------------
// Inlines:
//----------------------------------------------------------------------------------------

inline bool16 PMRect::IsEmpty() const noexcept
{
 return ((left == right) || (top == bottom));
}
 
inline bool16 PMRect::IsCorner(PointIndex whichPoint) const noexcept
{
 ASSERT_MSG(whichPoint >= kFirstPoint && whichPoint <= kLastPoint, "PMRect::IsCorner - whichPoint >= kFirstPoint && whichPoint <= kLastPoint");
 return (whichPoint >= kLeftTop && whichPoint != kCenter);
}

inline bool16 PMRect::IsMiddle(PointIndex whichPoint) const noexcept
{
 ASSERT_MSG(whichPoint >= kFirstPoint && whichPoint <= kLastPoint, "PMRect::IsMiddle - whichPoint >= kFirstPoint && whichPoint <= kLastPoint");
 return (whichPoint >= kMiddleTop && whichPoint <= kRightMiddle);
}

inline bool16 PMRect::PointIn(const PMPoint& pt) const noexcept
{
 return (pt.x >= left) && (pt.x <= right) && (pt.y >= top) && (pt.y <= bottom);
}

inline bool16 PMRect::ContainsPoint(const PMPoint& pt) const noexcept
{
 return 
 ::ToDouble(pt.x) >= ::ToDouble(left)
 && ::ToDouble(pt.x) <= ::ToDouble(right)
 && ::ToDouble(pt.y) >= ::ToDouble(top)
 && ::ToDouble(pt.y) <= ::ToDouble(bottom);
}


inline bool16 PMRect::RectIn(const PMRect& r) const noexcept
{
 return (top <= r.top && bottom >= r.bottom) && (left <= r.left && right >= r.right);
}

inline bool16 PMRect::ContainsRect(const PMRect& r) const noexcept
{
 return
 ::ToDouble(top) <= ::ToDouble(r.top)
 && ::ToDouble(bottom) >= ::ToDouble(r.bottom)
 && ::ToDouble(left) <= ::ToDouble(r.left)
 && ::ToDouble(right) >= ::ToDouble(r.right);
}

inline const PMReal& PMRect::Left() const noexcept
{
 return left;
}
 
inline PMReal& PMRect::Left() noexcept
{
 return left;
}

inline void PMRect::Left(const PMReal& c) noexcept
{
 left = c;
}
 
inline const PMReal& PMRect::Top() const noexcept
{
 return top;
}
 
inline PMReal& PMRect::Top() noexcept
{
 return top;
}

inline void PMRect::Top(const PMReal& c) noexcept
{
 top = c;
}
 
inline const PMReal& PMRect::Right() const noexcept
{
 return right;
}
 
inline PMReal& PMRect::Right() noexcept
{
 return right;
}

inline void PMRect::Right(const PMReal& c) noexcept
{
 right = c;
}
 
inline const PMReal& PMRect::Bottom() const noexcept
{
 return bottom;
}
 
inline PMReal& PMRect::Bottom() noexcept
{
 return bottom;
}

inline void PMRect::Bottom(const PMReal& c) noexcept
{
 bottom = c;
}
 
inline PMPoint PMRect::LeftTop() const noexcept
{
 return PMPoint(left, top);
}
 
inline void PMRect::LeftTop(const PMPoint& pt) noexcept
{
 left = pt.X(); top = pt.Y();
}
 
inline PMPoint PMRect::RightBottom() const noexcept
{
 return PMPoint(right, bottom);
}
 
inline void PMRect::RightBottom(const PMPoint& pt) noexcept
{
 right = pt.X(); bottom = pt.Y();
}

inline PMPoint PMRect::RightTop() const noexcept
{
 return PMPoint(right, top);
}
 
inline void PMRect::RightTop(const PMPoint& pt) noexcept
{
 right = pt.X(); top = pt.Y();
}
 
inline PMPoint PMRect::LeftBottom() const noexcept
{
 return PMPoint(left, bottom);
}
 
inline void PMRect::LeftBottom(const PMPoint& pt) noexcept
{
 left = pt.X(); bottom = pt.Y();
}
 
inline PMReal PMRect::Height() const noexcept
{
 return bottom - top;
}
 
inline PMReal PMRect::Width() const noexcept
{
 return right - left;
}

inline PMPoint PMRect::Dimensions() const noexcept
{
 return PMPoint(Width(), Height());
}
 
inline PMRect::PointIndex PMRect::GetOppositePointIndex(PointIndex whichPoint) const
{
 return (whichPoint == kCenter) ? kCenter :
 PointIndex((whichPoint + 2) % 4 + (IsCorner(whichPoint) ? 4 : 0));
}
 
 
inline PMPoint PMRect::GetOppositePoint(PointIndex whichPoint) const
{
 return GetPoint(GetOppositePointIndex(whichPoint));
}
 

inline PMRect& PMRect::SetEmpty() noexcept
{
 right = left;
 bottom = top;
 
 return *this;
}

inline PMRect& PMRect::MoveRel(const PMReal& dx, const PMReal& dy)
{
 left += dx; right += dx; top += dy; bottom += dy;
 return *this;
}

inline PMRect& PMRect::MoveRel(const PMPoint& point)
{
 MoveRel(point.X(), point.Y());
 return *this;
}

inline PMRect& PMRect::MoveTo(const PMReal& dx, const PMReal& dy)
{
 right += (dx - left); bottom += (dy - top); left = dx; top = dy;
 return *this;
}

inline PMRect& PMRect::MoveTo(const PMPoint& point)
{
 MoveTo(point.X(), point.Y());
 return *this;
}

inline PMRect& PMRect::CenterOn(const PMPoint& point)
{
 CenterOn(point.X(), point.Y());
 return *this;
}

inline PMRect& PMRect::Inset(const PMReal& dx, const PMReal& dy)
{
 left += dx; top += dy; right -= dx; bottom -= dy;
 return *this;
}

inline bool16 operator ==(const PMRect& a, const PMRect& b) noexcept
{
 return (a.left == b.left && a.top == b.top && a.right == b.right && a.bottom == b.bottom);
}

inline bool16 operator !=(const PMRect& a, const PMRect& b) noexcept
{
 return (a.left != b.left || a.top != b.top || a.right != b.right || a.bottom != b.bottom);
}

constexpr PMRect kZeroRect; //zeroed out in default constructor

#endif