Rect2D.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   Rect2D.h
//  AUTHOR      :   Liang Liu
//  CREATION    :   2008-09-25
//  Copyright (C) MicroStrategy Incorporated 2008
//  All Rights Reserved
//==============================================================================================

#ifndef MsiChart_Rect2D_h
#define MsiChart_Rect2D_h

#include "Point2D.h"

namespace MsiChart
{   
    typedef enum
    {
        REC_EXP_INVALID = 0,
        REC_EXP_HRIZONTAL = 1,
        REC_EXP_VERTICAL = 2,
        REC_EXP_BOTH = 3
    }REC_EXP_DIRECTION;

    class  Rect2D
    {
    public:
        Rect2D(int iX, int iY, 
            Int32 iWidth, Int32 iHeight) : x(iX),y(iY),width(iWidth),height(iHeight){}
        
        Rect2D(): x(0), y(0), width(0), height(0){}     

        void Explode(Int32 iXOffset, Int32 iYOffset);
        
        void Expand(Int32 iOffset, REC_EXP_DIRECTION iExpDirection);

        void Implode(Int32 iXOffset, Int32 iYOffset);

        Point2D GetTopLeft() const;
        Point2D GetBottomLeft() const;
        Point2D GetTopRight() const;
        Point2D GetBottomRight() const;
        Point2D GetCenter() const;
        Point2D GetLeftMiddle() const;
        Point2D GetTopMiddle() const;
        Point2D GetRightMiddle() const;
        Point2D GetBottomMiddle() const;
        bool HasIntersection(const Rect2D& irRect) const;
        bool PointInRectangle(const Point2D& irPoint) const;

        void Reset(int iX, int iY, Int32 iWidth, Int32 iHeight);
    
        bool IsEqualTo(Rect2D& irRect) const;
    public: 
        int x;      
        int y;      
        Int32 width;    
        Int32 height;   
    };

    inline void  Rect2D::Explode(Int32 iXOffset, Int32 iYOffset)
    {
        x -= iXOffset;
        y -= iYOffset;
        width += (iXOffset*2);
        height += (iYOffset*2);
    }

    inline void Rect2D::Expand(Int32 iOffset, REC_EXP_DIRECTION iExpDirection)
    {
//      if (iOffset <= 0)
//          return;
        
        if (iExpDirection & REC_EXP_HRIZONTAL)
        {
            x -= iOffset;
            width += 2 * iOffset;
        }
        
        if (iExpDirection & REC_EXP_VERTICAL)
        {
            y -= iOffset;
            height += 2 * iOffset;
        }
    }

    inline void Rect2D::Implode(Int32 iXOffset, Int32 iYOffset)
    {
        if (iXOffset * 2 > width)
        {
            iXOffset = width / 2;
        }
        if (iYOffset * 2 > height)
        {
            iYOffset = height / 2;
        }
        Rect2D::Explode(-iXOffset, -iYOffset);
    }

    inline Point2D Rect2D::GetTopLeft() const
    {
        return Point2D(x, y);
    }
    inline Point2D Rect2D::GetBottomLeft() const
    {
        return Point2D(x, y + height);
    }
    inline Point2D Rect2D::GetTopRight() const
    {
        return Point2D(x + width, y);
    }
    inline Point2D Rect2D::GetBottomRight() const
    {
        return Point2D(x + width, y + height);
    }
    inline Point2D Rect2D::GetCenter() const
    {
        return Point2D(x + width / 2, y + height / 2);
    }
    
    inline Point2D Rect2D::GetLeftMiddle() const
    {
        return Point2D(x, y + height / 2);
    }
        
    inline Point2D Rect2D::GetTopMiddle() const
    {
        return Point2D(x + width / 2, y);
    }
        
    inline Point2D Rect2D::GetRightMiddle() const
    {
        return Point2D(x + width, y + height / 2);
    }
    
    inline Point2D Rect2D::GetBottomMiddle() const
    {
        return Point2D(x + width / 2, y + height);
    }
    inline bool Rect2D::HasIntersection(const Rect2D& irRect) const
    {
        return x < (irRect.x + irRect.width) && irRect.x < (x + width) &&
            y < (irRect.y + irRect.height) && irRect.y < (y + height);
    }

    inline bool Rect2D::PointInRectangle(const Point2D& irPoint) const
    {
        return ((irPoint.x >= x) && (irPoint.x <= x + width)
            && (irPoint.y >= y) && (irPoint.y <= y + height));
    }

    inline void Rect2D::Reset(int iX, int iY, Int32 iWidth, Int32 iHeight)
    {
        x = iX;
        y = iY;
        width = iWidth;
        height = iHeight;
    }
    
    inline bool Rect2D::IsEqualTo(Rect2D& irRect) const
    {
        if (x != irRect.x || y != irRect.y)
            return false;
        if (width != irRect.width || height != irRect.height)
            return false;
        return true;
    }

}
#endif