PtRect.h

Go to the documentation of this file.

// -*- C++ -*-
/* GG is a GUI for SDL and OpenGL.
   Copyright (C) 2003 T. Zachary Laine

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1
   of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
    
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA

   If you do not wish to comply with the terms of the LGPL please
   contact the author as other terms are available for a fee.
    
   Zach Laine
   whatwasthataddress@hotmail.com */

#ifndef _GG_PtRect_h_
#define _GG_PtRect_h_

#include <GG/Base.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>

#include <iosfwd>


namespace GG {

struct GG_API Pt
{ 
    Pt();                       
    Pt(int x_, int y_);         

 

    bool Less(const Pt& rhs) const {return x < rhs.x ? true : (x == rhs.x ? (y < rhs.y ? true : false) : false);}
 
    void  operator+=(const Pt& rhs)      {x += rhs.x; y += rhs.y;} 
    void  operator-=(const Pt& rhs)      {x -= rhs.x; y -= rhs.y;} 
    Pt    operator-() const              {return Pt(-x, -y);}      


    int x; 
    int y; 

private:
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};

struct GG_API Rect
{ 
    Rect();                                
    Rect(const Pt& pt1, const Pt& pt2);    
    Rect(int x1, int y1, int x2, int y2);  

 
    int   Left() const         {return ul.x;}        
    int   Right() const        {return lr.x;}        
    int   Top() const          {return ul.y;}        
    int   Bottom() const       {return lr.y;}        
    Pt    UpperLeft() const    {return ul;}          
    Pt    LowerRight() const   {return lr;}          
    int   Width() const        {return lr.x - ul.x;} 
    int   Height() const       {return lr.y - ul.y;} 

    bool  Contains(const Pt& pt) const; 

 
    void operator+=(const Pt& pt)      {ul += pt; lr += pt;} 
    void operator-=(const Pt& pt)      {ul -= pt; lr -= pt;} 


    Pt ul; 
    Pt lr; 

private:
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};

GG_API inline bool operator==(const Pt& lhs, const Pt& rhs) {return lhs.x == rhs.x && lhs.y == rhs.y;} 
GG_API inline bool operator!=(const Pt& lhs, const Pt& rhs) {return !(lhs == rhs);}                    
GG_API inline bool operator<(const Pt& lhs, const Pt& rhs)  {return lhs.x < rhs.x && lhs.y < rhs.y;}   
GG_API inline bool operator>(const Pt& lhs, const Pt& rhs)  {return lhs.x > rhs.x && lhs.y > rhs.y;}   
GG_API inline bool operator<=(const Pt& lhs, const Pt& rhs) {return lhs.x <= rhs.x && lhs.y <= rhs.y;} 
GG_API inline bool operator>=(const Pt& lhs, const Pt& rhs) {return lhs.x >= rhs.x && lhs.y >= rhs.y;} 
GG_API inline Pt   operator+(const Pt& lhs, const Pt& rhs)  {return Pt(lhs.x + rhs.x, lhs.y + rhs.y);} 
GG_API inline Pt   operator-(const Pt& lhs, const Pt& rhs)  {return Pt(lhs.x - rhs.x, lhs.y - rhs.y);} 

GG_API std::ostream& operator<<(std::ostream& os, const Pt& pt); 

GG_API inline bool operator==(const Rect& lhs, const Rect& rhs) {return lhs.ul.x == rhs.ul.x && lhs.lr.x == rhs.lr.x && lhs.lr.x == rhs.lr.x && lhs.lr.y == rhs.lr.y;}

GG_API inline bool operator!=(const Rect& lhs, const Rect& rhs) {return !(lhs == rhs);}

GG_API inline Rect operator+(const Rect& rect, const Pt& pt) {return Rect(rect.ul + pt, rect.lr + pt);} 
GG_API inline Rect operator-(const Rect& rect, const Pt& pt) {return Rect(rect.ul - pt, rect.lr - pt);} 
GG_API inline Rect operator+(const Pt& pt, const Rect& rect) {return rect + pt;} 
GG_API inline Rect operator-(const Pt& pt, const Rect& rect) {return rect - pt;} 

GG_API std::ostream& operator<<(std::ostream& os, const Rect& rect); 

} // namepace GG

// template implementations
template <class Archive>
void GG::Pt::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(x)
        & BOOST_SERIALIZATION_NVP(y);
}

template <class Archive>
void GG::Rect::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(ul)
        & BOOST_SERIALIZATION_NVP(lr);
}

#endif // _GG_PtRect_h_

---