Stores the left, top, width and height of a rectangle. More...

#include <rectangle.h>

Public Member Functions
	Rectangle ()
	_______________________________________________TEMPLATES_________________________________________________________________///

	Rectangle (Type left, Type top, Type width, Type height)
	Creates a new rectangle, if width or height are negative, the left/top will be adjusted and the width/height made positive.

bool	intersects (const Rectangle< Type > &)

Rectangle< Type >	intersection (const Rectangle< Type > &)

Vector< Rectangle< Type > >	subtract (const Rectangle< Type > &)

bool	contains (const Rectangle< Type > &)

bool	contains (Type x, Type y)

Public Attributes
Type	left { 0 }
	The left coordinate of the rectangle.

Type	top { 0 }
	The top coordinate of the rectangle.

Type	width { 0 }
	The width of the rectangle.

Type	height { 0 }
	The height of the rectangle.

Detailed Description

template<class Type>
class MaxOS::common::Rectangle< Type >

Stores the left, top, width and height of a rectangle.

Template Parameters

Type	The type of the rectangle (assumed to be numeric)

Definition at line 22 of file rectangle.h.

Constructor & Destructor Documentation

◆ Rectangle()

template<class Type >

MaxOS::common::Rectangle< Type >::Rectangle	(	Type	left,
		Type	top,
		Type	width,
		Type	height
	)

Creates a new rectangle, if width or height are negative, the left/top will be adjusted and the width/height made positive.

Template Parameters

Type	The type of the rectangle

Parameters

left	The left coordinate
top	The top coordinate
width	The width of the rectangle
height	The height of the rectangle

Definition at line 56 of file rectangle.h.

            : left(left),
            top(top),
            width(width),
            height(height) {
 
        // If the width is negative, move the left and make the width positive
        if(width < 0) {
            left += width;
            width *= -1;
        }
 
        // If the m_height is negative, move the top and make the height positive
        if(height < 0) {
            top += height;
            height *= -1;
        }
 
        // Set the values
        this->left = left;
        this->top = top;
    }

References MaxOS::common::Rectangle< Type >::height, MaxOS::common::Rectangle< Type >::left, MaxOS::common::Rectangle< Type >::top, and MaxOS::common::Rectangle< Type >::width.

Member Function Documentation

◆ contains() [1/2]

template<class Type >

bool MaxOS::common::Rectangle< Type >::contains ( const Rectangle< Type > & other )

Checks if this rectangle contains another rectangle

Template Parameters

Type	The type of the rectangle

Parameters

other The other rectangle

Returns: True if this rectangle contains the other rectangle, false otherwise

Definition at line 192 of file rectangle.h.

                                                                                    {
 
        // If the other rectangle is to the left of this rectangle
        if(other.left + other.width <= left)
            return false;
 
        // If the other rectangle is to the right of this rectangle
        if(other.left >= left + width)
            return false;
 
        // If the other rectangle is above this rectangle
        if(other.top + other.height <= top)
            return false;
 
        // If the other rectangle is below this rectangle
        if(other.top >= top + height)
            return false;
 
        // If none of the above conditions are true, then the rectangles intersect
        return true;
    }

References MaxOS::common::Rectangle< Type >::height, MaxOS::common::Rectangle< Type >::left, MaxOS::common::Rectangle< Type >::top, and MaxOS::common::Rectangle< Type >::width.

Referenced by MaxOS::gui::Widget::contains_coordinate(), MaxOS::gui::CompositeWidget::on_mouse_enter_widget(), MaxOS::gui::CompositeWidget::on_mouse_leave_widget(), and MaxOS::gui::CompositeWidget::on_mouse_move_widget().

◆ contains() [2/2]

template<class Type >

bool MaxOS::common::Rectangle< Type >::contains	(	Type	x,
		Type	y
	)

Checks if this rectangle contains a point

Template Parameters

Type	The type of the rectangle

Parameters

x	The x coordinate of the point
y	The y coordinate of the point

Returns: True if this rectangle contains the point, false otherwise

Definition at line 223 of file rectangle.h.

                                                                      {
 
        // If the point is to the left of this rectangle
        if(x < left)
            return false;
 
        // If the point is to the right of this rectangle
        if(x >= left + width)
            return false;
 
        // If the point is above this rectangle
        if(y < top)
            return false;
 
        // If the point is below this rectangle
        if(y >= top + height)
            return false;
 
        // If none of the above conditions are true, then the point is inside the rectangle
        return true;
 
    }

References MaxOS::common::Rectangle< Type >::height, MaxOS::common::Rectangle< Type >::left, MaxOS::common::Rectangle< Type >::top, and MaxOS::common::Rectangle< Type >::width.

◆ intersection()

template<class Type >

Rectangle< Type > MaxOS::common::Rectangle< Type >::intersection ( const Rectangle< Type > & other )

Returns a retangle that represents the intersection of this rectangle and another rectangle

Template Parameters

Type	The type of the rectangle

Parameters

other The other rectangle

Returns: The intersection of the two rectangles

Definition at line 116 of file rectangle.h.

                                                                                                   {
        // If the rectangles don't intersect, return an empty rectangle
        if(!intersects(other))
            return Rectangle<Type>();
 
        // Get the left and top of the intersection using the maximum of the two
        Type i_left = this->left > other.left ? this->left : other.left;
        Type i_top = this->top > other.top ? this->top : other.top;
 
        // Get the right and bottom of the intersection using the minimum of the two
        Type right = this->left + this->width < other.left + other.width ? this->left + this->width : other.left +
                                                                                                      other.width;
        Type bottom = this->top + this->height < other.top + other.height ? this->top + this->height : other.top +
                                                                                                       other.height;
 
        // Return the intersection
        return Rectangle<Type>(i_left, i_top, right - left, bottom - top);
    }

References MaxOS::common::Rectangle< Type >::height, MaxOS::common::Rectangle< Type >::left, MaxOS::common::Rectangle< Type >::top, and MaxOS::common::Rectangle< Type >::width.

Referenced by MaxOS::gui::CompositeWidget::draw(), and MaxOS::gui::Window::draw_self().

◆ intersects()

template<class Type >

bool MaxOS::common::Rectangle< Type >::intersects ( const Rectangle< Type > & other )

Checks if the rectangle intersects with another rectangle

Template Parameters

Type	The type of the rectangle

Parameters

other The other rectangle

Returns: True if the rectangles intersect, false otherwise

Definition at line 88 of file rectangle.h.

                                                                                      {
        // If the other rectangle is to the left of this rectangle
        if(other.left + other.width <= left)
            return false;
 
        // If the other rectangle is to the right of this rectangle
        if(other.left >= left + width)
            return false;
 
        // If the other rectangle is above this rectangle
        if(other.top + other.height <= top)
            return false;
 
        // If the other rectangle is below this rectangle
        if(other.top >= top + height)
            return false;
 
        // If none of the above conditions are true, then the rectangles intersect
        return true;
    }

References MaxOS::common::Rectangle< Type >::height, MaxOS::common::Rectangle< Type >::left, MaxOS::common::Rectangle< Type >::top, and MaxOS::common::Rectangle< Type >::width.

Referenced by MaxOS::gui::widgets::Button::draw(), MaxOS::gui::widgets::InputBox::draw(), MaxOS::gui::CompositeWidget::draw(), MaxOS::gui::Window::draw_self(), MaxOS::gui::Desktop::internal_invalidate(), and MaxOS::common::Rectangle< Type >::subtract().

◆ subtract()

template<class Type >

Vector< Rectangle< Type > > MaxOS::common::Rectangle< Type >::subtract ( const Rectangle< Type > & other )

Subtracts a rectangle from this rectangle

Template Parameters

Type	The type of the rectangle

Parameters

other The rectangle to subtract

Returns: A vector of rectangles that represent the subtraction

Definition at line 142 of file rectangle.h.

                                                                                                       {
 
        // Store the result rectangle
        Vector<Rectangle<Type>> result;
 
        // Make sure the rectangles intersect
        if(!intersects(other)) {
            result.push_back(*this);
            return result;
        }
 
        // Get the minimum and maximum values for the width and height
        Type max_left = left > other.left ? left : other.left;
        Type min_right = (left + width < other.left + other.width ? left + width : other.left + other.width);
        Type min_bottom = (top + height < other.top + other.height ? top + height : other.top + other.height);
 
        // Add the non-intersecting rectangles to the result
 
        // Add non-overlapping region above if current top is less than other top
        if(top < other.top)
            result.push_back(Rectangle<Type>(max_left, top, min_right - max_left,
                                             other.top - top));
 
        // Add non-overlapping region to the left if current left is less than other left
        if(left < other.left)
            result.push_back(
                    Rectangle<Type>(left, top, other.left - left, height));
 
        // Add non-overlapping region to the right if current right is greater than other right
        if(left + width > other.left + other.width)
            result.push_back(Rectangle<Type>(
                    other.left + other.width, top,
                    (left + width) - (other.left + other.width) + 1, height));
 
        // Add non-overlapping region below if current bottom is greater than other bottom
        if(this->top + this->height > other.top + other.height)
            result.push_back(Rectangle<Type>(max_left, min_bottom,
                                             min_right - max_left,
                                             top + height - min_bottom + 1));
 
        return result;
    }