xrect.h

Go to the documentation of this file.

#if !defined( __ARSRECT_H__ )
#define __ARSRECT_H__

namespace Ars
{

class XPoint    {
public:
        int     x , y;

// Constructors

        // create from two integers
        XPoint( const int initX = 0, const int initY = 0 ) : x( initX ) , y( initY )    {}

        // create from another point
        XPoint( const XPoint &initPt) : x( initPt.x ) , y( initPt.y )   {};

// Operations
        XPoint operator+( const XPoint& p) const        {       return XPoint( x + p.x , y + p.y );     }
        XPoint operator-(const XPoint& p) const {       return XPoint( x - p.x , y - p.y );     }

        XPoint &operator/=( const double v )    {       x = (int)(x / v);       y = (int)(y / v);       return *this;   }
        XPoint &operator*=( const double v )    {       x = (int)(x * v);       y = (int)(y * v);       return *this;   }
        XPoint &operator/=( const int v )       {       x /= v; y /= v; return *this;   }
        XPoint &operator*=( const int v )       {       x *= v; y *= v; return *this;   }
        XPoint &operator+=( const int v )       {       x += v; y += v; return *this;   }
        XPoint &operator-=( const int v )       {       x -= v; y -= v; return *this;   }

        XPoint &operator=(const XPoint& p)      {       x = p.x;        y = p.y;        return *this;   }

        const bool operator==(const XPoint& p) const { return ((x == p.x) && (y == p.y)); }

        const bool leftof(const XPoint& p) const { return (x < p.x); }

        const bool rightof(const XPoint& p) const { return (x > p.x); }

        const bool above(const XPoint& p) const { return (y < p.y); }

        const bool below(const XPoint& p) const { return (y > p.y); }

        const double dist( void )       
        {       return sqrt( (double)x * x + (double)y * y );   }
};

class XRect     : public SDL_Rect       {
public:
        XRect( void )
        {       x = 0;  y = 0;  w = 0;  h = 0;  }  // constructor

        XRect(const int ax, const int ay, const int aw, const int ah) 
        {       x = ax; y = ay; w = aw; h = ah; }  // constructor

        XRect( const XPoint &p1 , const XPoint &p2 ) 
        {
                x = min( p2.x , p1.x ); y = min( p2.y , p1.y );
                w = max( p2.x , p1.x ) - x;
                h = max( p2.y , p1.y ) - y;
        }  // constructor

        XRect( const XRect &r ) 
        {       x = r.x;        y = r.y;        w = r.w;        h = r.h;        }  // constructor

        virtual ~XRect( void ) { }

        int Width(void) const { return (short int)w; }

        int Height(void) const { return (short int)h; }

        XPoint Size() const     {       return XPoint( w , h ); }

        XPoint TopLeft(void) const { return XPoint( x , y ); }

        XPoint TopRight(void) const { return XPoint( x + w, y ); }

        XPoint BottomLeft(void) const { return XPoint( x , y + h ); }

        XPoint BottomRight(void) const { return XPoint( x + w , y + h); }

        const int Right( void ) const           {       return x + Width();     }
        const int Bottom( void ) const  {       return y + Height();    }

        void SetBottom( const int y2 )  {       h = abs( y2 - y );      }
        void SetRight( const int x2 )   {       w = abs( x2 - x );      }

        XPoint Center(void) const       { return XPoint( x + (Width() >> 1) , y + (Height() >> 1) );    }

        operator SDL_Rect( void )       {       return static_cast<SDL_Rect>( *this );  }
        operator const SDL_Rect( void ) const   {       return static_cast<const SDL_Rect>( *this );    }

        XRect &operator=( const XRect &r )      {       x = r.x;        y = r.y;        w = r.w;        h = r.h;        return *this;   }  // assignment operator
        XRect &operator=( const SDL_Rect &r )   {       x = r.x;        y = r.y;        w = r.w;        h = r.h;        return *this;   }  // assignment operator

        XRect operator+( const XPoint &p ) const        {       return XRect( x + p.x , y + p.y , w , y );      }

        XRect operator-(const XPoint& p) const  {       return XRect( x - p.x , y - p.y , w , y );      }

        XRect &Grow( const int iGrowAmount )    {       x -= iGrowAmount;       y -= iGrowAmount;       w += 2 * iGrowAmount;   h += 2 * iGrowAmount;   return *this;   }

        const bool Overlaps( const XRect &r )
        {
                return (HitTest(r.TopLeft()) == RELPOS_INSIDE || HitTest(r.TopRight()) == RELPOS_INSIDE || HitTest(r.BottomRight()) == RELPOS_INSIDE
                         || HitTest(r.BottomLeft()) == RELPOS_INSIDE || r.HitTest(TopLeft()) == RELPOS_INSIDE || r.HitTest(TopRight()) == RELPOS_INSIDE
                         || r.HitTest(BottomRight()) == RELPOS_INSIDE || r.HitTest(BottomLeft()) == RELPOS_INSIDE);
        }

        void ClipTo( const XRect &r )
        {
                if( Overlaps( r ) )
                {
                        if( x < r.x )
                                x = r.x;
                        if( Right() > r.Right() )
                                SetRight( r.Right() );
        
                        if( y < r.y )   
                                y = r.y;
                        if( Bottom() > r.Bottom() )
                                SetBottom( r.Bottom() );
                }
                else
                        w = h = 0;
        }

        enum ERelativePosition
        {
                RELPOS_ABOVE = 1, 
                RELPOS_BELOW = 2, 
                RELPOS_LEFT = 4, 
                RELPOS_RIGHT = 8, 
                RELPOS_INSIDE = 16 
        };

        unsigned int HitTest( const XPoint &p ) const
        { 
                unsigned int eRelPos = 0;

                eRelPos |= (p.x < x) ? RELPOS_LEFT : 0;
                eRelPos |= (p.y < y) ? RELPOS_ABOVE: 0;
                eRelPos |= (p.x > (x+w)) ? RELPOS_RIGHT : 0;
                eRelPos |= (p.y > (y+h)) ? RELPOS_BELOW: 0;
                eRelPos |= (p.x >= x && p.x <= (x+w) && p.y >= y && p.y <= (y+h)) ? RELPOS_INSIDE : 0;

                return eRelPos;
        }
};

static XRect    emptyRect( 0 , 0 , 0 , 0 );

}

#endif

---