PMPoint.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 __PMPOINT__
#define __PMPOINT__

#include "PMReal.h"
#include "SystemUtils.h"
#include "K2Vector.h"

//----------------------------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------------------------
class PMPoint;
class PMRect;
class IPMStream;

//----------------------------------------------------------------------------------------
// 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 PMPoint
//----------------------------------------------------------------------------------------
typedef PMPoint PBPMPoint; // point in "Pasteboard" PMRealinates
typedef PMPoint IPMPoint; // point in "Inner" PMRealinates of page item
typedef K2Vector<PMPoint> PMPointList;
typedef K2Vector<PMPointList*> PMPointListCollection;

//----------------------------------------------------------------------------------------
// PMPoint
//----------------------------------------------------------------------------------------

// Math Operators
PMPoint operator +(const PMPoint& a, const PMPoint& b);
PMPoint operator -(const PMPoint& a, const PMPoint& b);
PMPoint operator -(const PMPoint& a);
PMPoint operator *(const PMReal& c, const PMPoint& pt);
PMPoint operator *(const PMPoint& pt, const PMReal& c);
PMPoint operator *(const PMPoint& a, const PMPoint& b);
PMPoint operator /(const PMPoint& numer, const PMPoint& denom);
PMPoint operator /(const PMPoint& numer, const PMReal& denom);


class PMPoint
{
 public:
 typedef base_type data_type;
 
 constexpr PMPoint() noexcept: x(0.0), y(0.0)
 {}
 
 constexpr PMPoint(const PMPoint &) noexcept = default;
 constexpr PMPoint(PMPoint &&) noexcept = default;
 PMPoint &operator =(const PMPoint &) noexcept = default;
 PMPoint &operator =(PMPoint &&) noexcept = default;
 
 constexpr PMPoint(const PMReal& x_orig, const PMReal& y_orig) noexcept : x(x_orig), y(y_orig)
 {}
 
 constexpr PMPoint(const SysPoint& p) noexcept: x(double(SysPointH(p))), y(double(SysPointV(p)))
 {}

 // Outbound Conversions
 
 friend SysPoint ToSys(const PMPoint& pt);

 // Accessor Methods
 
 const PMReal& X() const noexcept
 { return x; }
 
 PMReal& X() noexcept
 { return x; }
 
 void X(const PMReal& xParam) noexcept
 { x = xParam; }

 const PMReal& Y() const noexcept
 { return y; }

 PMReal& Y() noexcept
 { return y; }

 void Y(const PMReal& yParam) noexcept
 { y = yParam; }

 PMReal Distance (const PMPoint& otherPt) const
 {
 return (otherPt - *this).VectorLength();
 }

 PMReal VectorLength() const
 {
 if( ::ToDouble(x) == 0.) //convert to double to get exact comparison
 return abs(y); //avoid roundof error from sqrt(y*y)
 if( ::ToDouble(y) == 0.)
 return abs(x); //avoid roundof error from sqrt(x*x)
 return PMReal(std::sqrt(::ToDouble(x*x + y*y)));
 }

 PMReal VectorAngle() const;
 
 PMPoint MirrorPoint(const PMPoint& aligningPoint) const
 { return PMReal(2.0) * aligningPoint - *this; }

 PMPoint ProjectOnLine(const PMPoint& pt0, const PMPoint &ptA) const;

 // Math Operators
 
 friend PMPoint operator +(const PMPoint& a, const PMPoint& b);
 
 friend PMPoint operator -(const PMPoint& a, const PMPoint& b);
 
 friend PMPoint operator -(const PMPoint& a);
 
 friend PMPoint operator *(const PMReal& c, const PMPoint& pt);

 friend PMPoint operator *(const PMPoint& pt, const PMReal& c);
 
 friend PMPoint operator *(const PMPoint& a, const PMPoint& b);
 
 friend PMPoint operator /(const PMPoint& numer, const PMPoint& denom);
 
 friend PMPoint operator /(const PMPoint& numer, const PMReal& denom);

 // Assignment Operators
 
 void operator +=(const PMPoint& a)
 { x += a.x; y += a.y; }

 void operator -=(const PMPoint& a)
 { x -= a.x; y -= a.y; }

 // Comparison Operators
 
 friend bool16 operator ==(const PMPoint& a, const PMPoint& b) noexcept;
 
 friend bool16 operator !=(const PMPoint& a, const PMPoint& b) noexcept;


 bool operator<( const PMPoint& rhs) const noexcept
 {
 return x == rhs.x
 ? y < rhs.y
 : x < rhs.x;
 }



 // Manipulation Methods
 
 bool16 ConstrainTo(const PMRect& r);
 
 void Round()
 { x = ::Round(x); y = ::Round(y); }

 // Streaming
 
 void ReadWrite (IPMStream* iPMStream);

 private:
 PMReal x, y;
 friend class PMRect;
};

constexpr PMPoint kZeroPoint(0, 0);
constexpr PMPoint kInvalidPoint(kPMMaxReal, kPMMaxReal);




//----------------------------------------------------------------------------------------
// operator +
//----------------------------------------------------------------------------------------

inline PMPoint operator +(const PMPoint& a, const PMPoint& b)
{
 return PMPoint(a.x + b.x, a.y + b.y);
}

//----------------------------------------------------------------------------------------
// operator -
//----------------------------------------------------------------------------------------

inline PMPoint operator -(const PMPoint& a, const PMPoint& b)
{
 return PMPoint(a.x - b.x, a.y - b.y);
}

//----------------------------------------------------------------------------------------
// operator -
//----------------------------------------------------------------------------------------

inline PMPoint operator -(const PMPoint& a)
{
 return PMPoint(-a.x, -a.y);
}

//----------------------------------------------------------------------------------------
// operator *
//----------------------------------------------------------------------------------------

inline PMPoint operator *(const PMReal& c, const PMPoint& pt)
{
 return PMPoint(c * pt.x, c * pt.y);
}

//----------------------------------------------------------------------------------------
// operator *
//----------------------------------------------------------------------------------------

inline PMPoint operator *(const PMPoint& pt, const PMReal& c)
{
 return PMPoint(c * pt.x, c * pt.y);
}

//----------------------------------------------------------------------------------------
// operator *
//----------------------------------------------------------------------------------------

inline PMPoint operator *(const PMPoint& a, const PMPoint& b)
{
 return PMPoint(a.x * b.x, a.y * b.y);
}

//----------------------------------------------------------------------------------------
// operator /
//----------------------------------------------------------------------------------------

inline PMPoint operator /(const PMPoint& numer, const PMPoint& denom)
{
 return PMPoint(numer.x/denom.x, numer.y/denom.y);
}

//----------------------------------------------------------------------------------------
// operator /
//----------------------------------------------------------------------------------------

inline PMPoint operator /(const PMPoint& numer, const PMReal& denom)
{
 return PMPoint(numer.x/denom, numer.y/denom);
}


//----------------------------------------------------------------------------------------
// PMPoint::operator ==
//----------------------------------------------------------------------------------------

inline bool16 operator ==(const PMPoint& a, const PMPoint& b) noexcept
{
 return a.x == b.x && a.y == b.y;
}

//----------------------------------------------------------------------------------------
// PMPoint::operator !=
//----------------------------------------------------------------------------------------

inline bool16 operator !=(const PMPoint& a, const PMPoint& b) noexcept
{
 return a.x != b.x || a.y != b.y;
}

inline SysPoint ToSys(const PMPoint& pt)
{
 SysPoint sysPt;
#if MACINTOSH
 // Convert to the native coordinate system, but keep the coordinates integral
 // (djb - this is assumed to happen in many places currently)
 SysPointH(sysPt) = ::ToFloat(::Floor(pt.x));
 SysPointV(sysPt) = ::ToFloat(::Floor(pt.y));
#else
 SysPointH(sysPt) = ToInt32(pt.x);
 SysPointV(sysPt) = ToInt32(pt.y);
#endif
 return sysPt;
}


#endif