PMLineSeg.h

//========================================================================================
// 
// $File$
// 
// Owner: Ric Kamicar
// 
// $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.
// 
// 
// Simple class to hold two points. The line is vertically directional, meaning that top <= bottom.
// The line is primarily vertical, so the object is optimized for that.
// Also, UNLIKE PMReal, this class asserts if the object is ill-formed (PMRect silently normalizes).
// 
//========================================================================================

#ifndef __PMLineSeg__
#define __PMLineSeg__

#include "PMPoint.h"


class PMLineSeg
{
public:
 PMLineSeg()
 { }

 PMLineSeg(const PMPoint& P1, const PMPoint& P2) :
 fTop(P1), fBottom(P2)
 {
 if (fTop.Y() > fBottom.Y()) {
 fTop = P2;
 fBottom = P1;
 }
 ASSERT(fTop.Y() <= fBottom.Y());
 }

 PMLineSeg(const PMPoint& P1, const PMReal& xDistance, const PMReal& yDistance) :
 fTop(P1)
 {
 ASSERT(yDistance >= 0);
 fBottom = PMPoint(fTop.X() + xDistance, fTop.Y() + yDistance);
 }

 PMLineSeg(const PMReal& p1x, const PMReal& p1y, const PMReal& p2x, const PMReal& p2y)
 {
 ASSERT(p1y <= p2y);
 fTop = PMPoint(p1x, p1y);
 fBottom = PMPoint(p2x, p2y);
 }

 bool16 IsHorizontal() const
 {
 return fBottom.Y() == fTop.Y();
 }

 bool16 IsVertical() const
 {
 return fBottom.X() == fTop.X();
 }

 PMReal DeltaX() const
 {
 return fBottom.X() - fTop.X();
 }

 PMReal DeltaY() const
 {
 return fBottom.Y() - fTop.Y();
 }

 // Accessor Methods
 const PMPoint& TopPoint() const
 {
 return fTop;
 }

 const PMPoint& BottomPoint() const
 {
 return fBottom;
 }

#if ZERO
 PMPoint& TopPoint()
 {
 return fTop;
 }
 void TopPoint(const PMPoint& newP1)
 {
 fTop = newP1;
 }

 PMPoint& BottomPoint()
 {
 return fBottom;
 }
 void BottomPoint(const PMPoint& newP2)
 {
 fBottom = newP2;
 }
#endif

 const PMReal& Top() const
 {
 return fTop.Y();
 }

 PMReal& Top()
 {
 return fTop.Y();
 }

 void Top(const PMReal& newP1y)
 {
 fTop.Y(newP1y);
 ASSERT(fTop.Y() <= fBottom.Y());
 }

 const PMReal& Bottom() const
 {
 return fBottom.Y();
 }
 PMReal& Bottom() 
 {
 return fBottom.Y();
 }
 void Bottom(const PMReal& newP2y)
 {
 fBottom.Y(newP2y);
 ASSERT(fTop.Y() <= fBottom.Y());
 }

 const PMReal& Left() const
 {
 return fTop.X() > fBottom.X() ? fBottom.X() : fTop.X();
 }
 PMReal& Left()
 {
 return fTop.X() > fBottom.X() ? fBottom.X() : fTop.X();
 }
 void Left(const PMReal& newLeft)
 {
 if (fTop.X() > fBottom.X())
 {
 // The left point was also the bottom point. Will it still be?
 ASSERT_MSG(fTop.X() >= newLeft, "Swapping left and right points. Is this really what you want?");
 fBottom.X(newLeft);
 }
 else
 {
 ASSERT_MSG(newLeft <= fBottom.X(), "Swapping left and right points. Is this really what you want?");
 fTop.X(newLeft);
 }
 }

 const PMReal& Right() const
 {
 return fTop.X() > fBottom.X() ? fTop.X() : fBottom.X();
 }
 PMReal& Right()
 {
 return fTop.X() > fBottom.X() ? fTop.X() : fBottom.X();
 }
 void Right(const PMReal& newRight)
 {
 if (fTop.X() > fBottom.X())
 {
 // The right point was also the top point. Will it still be?
 ASSERT_MSG(newRight >= fBottom.X(), "Swapping left and right points. Is this really what you want?");
 fTop.X(newRight);
 }
 else
 {
 ASSERT_MSG(fTop.X() <= newRight, "Swapping left and right points. Is this really what you want?");
 fBottom.X(newRight);
 }
 }

 void SetX(const PMReal& x1, const PMReal& x2)
 {
 fTop.X(x1);
 fBottom.X(x2);
 }

 void SetY(const PMReal& y1, const PMReal& y2)
 {
 ASSERT(y1 <= y2);

 fTop.Y(y1);
 fBottom.Y(y2);
 }

 void SetHorizontal(const PMReal& x1, const PMReal& x2)
 {
 fTop.X(x1);
 fBottom.X(x2);
 fTop.Y(0.);
 fBottom.Y(0.);
 }

 void SetVertical(const PMReal& y1, const PMReal& y2)
 {
 ASSERT(y1 <= y2);

 fTop.X(0.);
 fBottom.X(0.);
 fTop.Y(y1);
 fBottom.Y(y2);
 }

 PMLineSeg& MoveRel(const PMReal& dx, const PMReal& dy)
 {
 if (dx != 0.)
 {
 fTop.X() += dx;
 fBottom.X() += dx;
 }
 if (dy != 0.)
 {
 fTop.Y() += dy;
 fBottom.Y() += dy;
 }
 return *this;
 }

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

 // Comparison operator
 friend bool16 operator ==(const PMLineSeg& a, const PMLineSeg& b);
 friend bool16 operator !=(const PMLineSeg& a, const PMLineSeg& b);

private:
 PMPoint fTop;
 PMPoint fBottom;
};


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

inline bool16 operator ==(const PMLineSeg& a, const PMLineSeg& b)
{
 return a.TopPoint() == b.TopPoint() && a.BottomPoint() == b.BottomPoint();
}

inline bool16 operator !=(const PMLineSeg& a, const PMLineSeg& b)
{
 return a.TopPoint() != b.TopPoint() || a.BottomPoint() != b.BottomPoint();
}

#endif