xref: /haiku/src/kits/interface/Rect.cpp (revision c302a243e15e640fae0f689e32cdf0c18749afee)

/*
 * Copyright 2001-2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Frans van Nispen
 *		John Scipione, jscipione@gmail.com
 */


#include <Rect.h>

#include <algorithm>

#include <stdio.h>


void
BRect::SetLeftTop(const BPoint point)
{
	left = point.x;
	top = point.y;
}


void
BRect::SetRightBottom(const BPoint point)
{
	right = point.x;
	bottom = point.y;
}


void
BRect::SetLeftBottom(const BPoint point)
{
	left = point.x;
	bottom = point.y;
}


void
BRect::SetRightTop(const BPoint point)
{
	right = point.x;
	top = point.y;
}


void
BRect::InsetBy(BPoint point)
{
	left += point.x;
	right -= point.x;
	top += point.y;
	bottom -= point.y;
}


void
BRect::InsetBy(float dx, float dy)
{
	left += dx;
	right -= dx;
	top += dy;
	bottom -= dy;
}


BRect&
BRect::InsetBySelf(BPoint point)
{
	InsetBy(point);
	return *this;
}


BRect&
BRect::InsetBySelf(float dx, float dy)
{
	InsetBy(dx, dy);
	return *this;
}


BRect
BRect::InsetByCopy(BPoint point) const
{
	BRect copy(*this);
	copy.InsetBy(point);
	return copy;
}


BRect
BRect::InsetByCopy(float dx, float dy) const
{
	BRect copy(*this);
	copy.InsetBy(dx, dy);
	return copy;
}


void
BRect::OffsetBy(BPoint point)
{
	left += point.x;
	right += point.x;
	top += point.y;
	bottom += point.y;
}


void
BRect::OffsetBy(float dx, float dy)
{
	left += dx;
	right += dx;
	top += dy;
	bottom += dy;
}


BRect&
BRect::OffsetBySelf(BPoint point)
{
	OffsetBy(point);
	return *this;
}


BRect&
BRect::OffsetBySelf(float dx, float dy)
{
	OffsetBy(dx, dy);
	return *this;
}


BRect
BRect::OffsetByCopy(BPoint point) const
{
	BRect copy(*this);
	copy.OffsetBy(point);
	return copy;
}


BRect
BRect::OffsetByCopy(float dx, float dy) const
{
	BRect copy(*this);
	copy.OffsetBy(dx, dy);
	return copy;
}


void
BRect::OffsetTo(BPoint point)
{
	right = (right - left) + point.x;
	left = point.x;
	bottom = (bottom - top) + point.y;
	top = point.y;
}


void
BRect::OffsetTo(float x, float y)
{
	right = (right - left) + x;
	left = x;
	bottom = (bottom - top) + y;
	top=y;
}


BRect&
BRect::OffsetToSelf(BPoint point)
{
	OffsetTo(point);
	return *this;
}


BRect&
BRect::OffsetToSelf(float x, float y)
{
	OffsetTo(x, y);
	return *this;
}


BRect
BRect::OffsetToCopy(BPoint point) const
{
	BRect copy(*this);
	copy.OffsetTo(point);
	return copy;
}


BRect
BRect::OffsetToCopy(float x, float y) const
{
	BRect copy(*this);
	copy.OffsetTo(x, y);
	return copy;
}


void
BRect::PrintToStream() const
{
	printf("BRect(l:%.1f, t:%.1f, r:%.1f, b:%.1f)\n", left, top, right, bottom);
}


bool
BRect::operator==(BRect other) const
{
	return left == other.left && right == other.right &&
		top == other.top && bottom == other.bottom;
}


bool
BRect::operator!=(BRect other) const
{
	return !(*this == other);
}


BRect
BRect::operator&(BRect other) const
{
	return BRect(std::max(left, other.left), std::max(top, other.top),
		std::min(right, other.right), std::min(bottom, other.bottom));
}


BRect
BRect::operator|(BRect other) const
{
	return BRect(std::min(left, other.left), std::min(top, other.top),
		std::max(right, other.right), std::max(bottom, other.bottom));
}


bool
BRect::Intersects(BRect rect) const
{
	if (!IsValid() || !rect.IsValid())
		return false;

	return !(rect.left > right || rect.right < left
		|| rect.top > bottom || rect.bottom < top);
}


bool
BRect::Contains(BPoint point) const
{
	return point.x >= left && point.x <= right
		&& point.y >= top && point.y <= bottom;
}


bool
BRect::Contains(BRect rect) const
{
	return rect.left >= left && rect.right <= right
		&& rect.top >= top && rect.bottom <= bottom;
}


// #pragma mark - BeOS compatibility only
#if __GNUC__ == 2


extern "C" BRect
InsetByCopy__5BRectG6BPoint(BRect* self, BPoint point)
{
	BRect copy(*self);
	copy.InsetBy(point);
	return copy;
}


extern "C" BRect
InsetByCopy__5BRectff(BRect* self, float dx, float dy)
{
	BRect copy(*self);
	copy.InsetBy(dx, dy);
	return copy;
}


extern "C" BRect
OffsetByCopy__5BRectG6BPoint(BRect* self, BPoint point)
{
	BRect copy(*self);
	copy.OffsetBy(point);
	return copy;
}


extern "C" BRect
OffsetByCopy__5BRectff(BRect* self, float dx, float dy)
{
	BRect copy(*self);
	copy.OffsetBy(dx, dy);
	return copy;
}


extern "C" BRect
OffsetToCopy__5BRectG6BPoint(BRect* self, BPoint point)
{
	BRect copy(*self);
	copy.OffsetTo(point);
	return copy;
}


extern "C" BRect
OffsetToCopy__5BRectff(BRect* self, float dx, float dy)
{
	BRect copy(*self);
	copy.OffsetTo(dx, dy);
	return copy;
}


#elif __GNUC__ >= 4
// TODO: remove this when new GCC 4 packages have to be built anyway


extern "C" BRect
_ZN5BRect11InsetByCopyE6BPoint(BRect* self, BPoint point)
{
	BRect copy(*self);
	copy.InsetBy(point);
	return copy;
}


extern "C" BRect
_ZN5BRect11InsetByCopyEff(BRect* self, float dx, float dy)
{
	BRect copy(*self);
	copy.InsetBy(dx, dy);
	return copy;
}


extern "C" BRect
_ZN5BRect12OffsetByCopyE6BPoint(BRect* self, BPoint point)
{
	BRect copy(*self);
	copy.OffsetBy(point);
	return copy;
}


extern "C" BRect
_ZN5BRect12OffsetByCopyEff(BRect* self, float dx, float dy)
{
	BRect copy(*self);
	copy.OffsetBy(dx, dy);
	return copy;
}


extern "C" BRect
_ZN5BRect12OffsetToCopyE6BPoint(BRect* self, BPoint point)
{
	BRect copy(*self);
	copy.OffsetTo(point);
	return copy;
}


extern "C" BRect
_ZN5BRect12OffsetToCopyEff(BRect* self, float dx, float dy)
{
	BRect copy(*self);
	copy.OffsetTo(dx, dy);
	return copy;
}


#endif	// __GNUC__ >= 4