TbRect.h

Go to the documentation of this file.

#pragma once
#include "Pop3Types.h"
#include <Pop3Point.h>

#include "TbPoint.h"

//***************************************************************************
// <t>>TbRect<< : A rectangle (inclusive, exclusive pairs)
//***************************************************************************
LB_API_CLASS(TbRect)
{
    LB_PUBLIC_MEMBERS
    SINT Left, Top, Right, Bottom;

    inline void Set(SINT l, SINT t, SINT r, SINT b)
    {
        Left = l;
        Right = r;
        Top = t;
        Bottom = b;
    };

    // default Constructor
    TbRect()
    {
        Left = Top = Right = Bottom = 0;
    };

    // all the bits constructor
    TbRect(SINT l, SINT t, SINT r, SINT b)
    {
        Set(l, t, r, b);
    };

    // a point and size constructor
    TbRect(const Pop3Point& Point, const Pop3Size& Size)
    {
        Left = Point.X;
        Top = Point.Y;
        Right = Point.X + Size.Width;
        Bottom = Point.Y + Size.Height;
    }

    // a size only constructor
    TbRect(const Pop3Size& size)
    {
        Left = 0;
        Top = 0;
        Right = size.Width;
        Bottom = size.Height;
    }

    TbRect(const Pop3Point& topLeft, const Pop3Point& botRight)
    {
        Left = topLeft.X;
        Top = topLeft.Y;
        Right = botRight.X;
        Bottom = botRight.Y;
    }

    // assignment
    //TbRect    operator=( const TbRect& rhs ) { Left=rhs.Left; Right=rhs.Right; Top=rhs.Top; Bottom=rhs.Bottom; return *this;}
    TbRect operator=(const Pop3Point& rhs)
    {
        Left = rhs.X;
        Right = rhs.X;
        Top = rhs.Y;
        Bottom = rhs.Y;
        return *this;
    }

    TbRect operator=(const Pop3Size& rhs)
    {
        Left = 0;
        Right = rhs.Width;
        Top = 0;
        Bottom = rhs.Height;
        return *this;
    }

    // Comparison
    BOOL operator==(const TbRect& a) const
    {
        return ((Left == a.Left) && (Right == a.Right) && (Top == a.Top) && (Bottom == a.Bottom));
    };

    BOOL operator!=(const TbRect& a) const
    {
        return ((Left != a.Left) || (Right != a.Right) || (Top != a.Top) || (Bottom != a.Bottom));
    };

    // Decompose into size and point
    Pop3Point GetPosition() const
    {
        return Pop3Point(Left, Top);
    };

    Pop3Size GetSize() const
    {
        return Pop3Size(UINT(Right - Left), UINT(Bottom - Top));
    };

    Pop3Point GetBottomRight() const
    {
        return Pop3Point(Right, Bottom);
    };

    Pop3Point GetTopRight() const
    {
        return Pop3Point(Right, Top);
    };

    Pop3Point GetBottomLeft() const
    {
        return Pop3Point(Left, Bottom);
    };

    // alter the size
    void Grow(SINT dx, SINT dy)
    {
        Left -= dx;
        Right += dx;
        Top -= dy;
        Bottom += dy;
    };

    void Shrink(SINT dx, SINT dy)
    {
        Left += dx;
        Right -= dx;
        Top += dy;
        Bottom -= dy;
    };

    // Intersection
    TbRect Intersection(const TbRect& a) const;
    BOOL Intersects(const TbRect& a) const;

    // Containment check
    BOOL Contains(const Pop3Point& a) const
    {
        return ((a.X >= Left) && (a.X < Right) && (a.Y >= Top) && (a.Y < Bottom));
    };

    BOOL Contains(const TbRect& a) const
    {
        return ((Left <= a.Left) && (Top <= a.Top) && (Right >= a.Right) && (Bottom >= a.Bottom));
    };

    // Repositioning via arithmetic operations
    TbRect operator+(const Pop3Point& a) const
    {
        return TbRect(Left + a.X, Top + a.Y, Right + a.X, Bottom + a.Y);
    };

    TbRect operator-(const Pop3Point& a) const
    {
        return TbRect(Left - a.X, Top - a.Y, Right - a.X, Bottom - a.Y);
    };

    TbRect operator+=(const Pop3Point& a)
    {
        Left += a.X;
        Top += a.Y;
        Right += a.X;
        Bottom += a.Y;
        return *this;
    };

    TbRect operator-=(const Pop3Point& a)
    {
        Left -= a.X;
        Top -= a.Y;
        Right -= a.X;
        Bottom -= a.Y;
        return *this;
    };

    // Repositioning and resizing
    void Empty()
    {
        Right = Left;
        Bottom = Top;
    };
    void Offset(Pop3Point& a)
    {
        Offset(TbPoint(a));
    }

    void Offset(TbPoint& a);

    void SetPosition(const Pop3Point& a);
    void SetPosition(SINT x, SINT y);
    void SetBottomRight(const Pop3Point& a);
    void SetBottomRight(SINT x, SINT y);

    void SetSize(const TbSize& a);

    void SetSize(const Pop3Size& a)
    {
        SetSize(TbSize(a));
    }

    void Set(const Pop3Point& topleft, const Pop3Size& size)
    {
        SetPosition(topleft);
        SetSize(size);
    };

    void Set(const Pop3Point& topleft, const Pop3Point& botright)
    {
        SetPosition(topleft);
        SetBottomRight(botright);
    };

    // Null check
    BOOL IsNull() const
    {
        return ((Left == Right) || (Top == Bottom));
    };

    BOOL IsEmpty() const
    {
        return ((Left == Right) || (Top == Bottom));
    };

    // Normalised Check
    BOOL IsNormal() const;

    // Return Width of rectangle
    SINT Width() const
    {
        return Right - Left;
    };

    // Return Height of rectangle
    SINT Height() const
    {
        return Bottom - Top;
    };

    // Calculate bounding rectangle
    TbRect Bounding(const TbRect& a) const;

    // Normalise
    void Normalise();
};