gfx Namespace Reference

Classes
class	Insets
class	InsetsF
class	Point
class	PointF
class	Range
class	Rect
class	RectF
class	Size
class	SizeF
class	Transform
class	Vector2d
class	Vector2dF

Typedefs
typedef struct _UnimplementedNativeViewAccessible	UnimplementedNativeViewAccessible
typedef UnimplementedNativeViewAccessible *	NativeViewAccessible
typedef intptr_t	NativeViewId

Functions
Insets	operator+ (Insets lhs, const Insets &rhs)
Insets	operator- (Insets lhs, const Insets &rhs)
InsetsF	operator+ (InsetsF lhs, const InsetsF &rhs)
InsetsF	operator- (InsetsF lhs, const InsetsF &rhs)
Point	ScaleToCeiledPoint (const Point &point, float x_scale, float y_scale)
Point	ScaleToCeiledPoint (const Point &point, float scale)
Point	ScaleToFlooredPoint (const Point &point, float x_scale, float y_scale)
Point	ScaleToFlooredPoint (const Point &point, float scale)
Point	ScaleToRoundedPoint (const Point &point, float x_scale, float y_scale)
Point	ScaleToRoundedPoint (const Point &point, float scale)
bool	operator== (const Point &lhs, const Point &rhs)
bool	operator!= (const Point &lhs, const Point &rhs)
Point	operator+ (const Point &lhs, const Vector2d &rhs)
Point	operator- (const Point &lhs, const Vector2d &rhs)
Vector2d	operator- (const Point &lhs, const Point &rhs)
Point	PointAtOffsetFromOrigin (const Vector2d &offset_from_origin)
void	PrintTo (const Point &point, ::std::ostream *os)
Point	ToFlooredPoint (const PointF &point)
Point	ToCeiledPoint (const PointF &point)
Point	ToRoundedPoint (const PointF &point)
PointF	ScalePoint (const PointF &p, float x_scale, float y_scale)
bool	operator== (const PointF &lhs, const PointF &rhs)
bool	operator!= (const PointF &lhs, const PointF &rhs)
PointF	operator+ (const PointF &lhs, const Vector2dF &rhs)
PointF	operator- (const PointF &lhs, const Vector2dF &rhs)
Vector2dF	operator- (const PointF &lhs, const PointF &rhs)
PointF	PointAtOffsetFromOrigin (const Vector2dF &offset_from_origin)
PointF	ScalePoint (const PointF &p, float scale)
void	PrintTo (const PointF &point, ::std::ostream *os)
	TEST (PointTest, ToPointF)
	TEST (PointTest, IsOrigin)
	TEST (PointTest, VectorArithmetic)
	TEST (PointTest, OffsetFromPoint)
	TEST (PointTest, ToRoundedPoint)
	TEST (PointTest, Scale)
	TEST (PointTest, ClampPoint)
	TEST (PointTest, ClampPointF)
	TEST (PointTest, Offset)
	TEST (PointTest, VectorMath)
	TEST (PointTest, IntegerOverflow)
void	AdjustAlongAxis (int dst_origin, int dst_size, int *origin, int *size)
static void	SaturatedClampRange (int min, int max, int *origin, int *span)
Rect	operator+ (const Rect &lhs, const Vector2d &rhs)
Rect	operator- (const Rect &lhs, const Vector2d &rhs)
Rect	IntersectRects (const Rect &a, const Rect &b)
Rect	UnionRects (const Rect &a, const Rect &b)
Rect	SubtractRects (const Rect &a, const Rect &b)
Rect	BoundingRect (const Point &p1, const Point &p2)
bool	operator== (const Rect &lhs, const Rect &rhs)
bool	operator!= (const Rect &lhs, const Rect &rhs)
Rect	operator+ (const Vector2d &lhs, const Rect &rhs)
Rect	ScaleToEnclosingRect (const Rect &rect, float x_scale, float y_scale)
Rect	ScaleToEnclosingRect (const Rect &rect, float scale)
Rect	ScaleToEnclosingRectSafe (const Rect &rect, float x_scale, float y_scale)
Rect	ScaleToEnclosingRectSafe (const Rect &rect, float scale)
Rect	ScaleToEnclosedRect (const Rect &rect, float x_scale, float y_scale)
Rect	ScaleToEnclosedRect (const Rect &rect, float scale)
Rect	ScaleToRoundedRect (const Rect &rect, float x_scale, float y_scale)
Rect	ScaleToRoundedRect (const Rect &rect, float scale)
void	PrintTo (const Rect &rect, ::std::ostream *os)
Rect	ToEnclosingRect (const RectF &r)
Rect	ToEnclosingRectIgnoringError (const RectF &r, float error)
Rect	ToEnclosedRect (const RectF &rect)
Rect	ToEnclosedRectIgnoringError (const RectF &r, float error)
Rect	ToNearestRect (const RectF &rect)
bool	IsNearestRectWithinDistance (const gfx::RectF &rect, float distance)
gfx::Rect	ToRoundedRect (const gfx::RectF &rect)
Rect	ToFlooredRectDeprecated (const RectF &rect)
static void	AdjustAlongAxis (float dst_origin, float dst_size, float *origin, float *size)
RectF	IntersectRects (const RectF &a, const RectF &b)
RectF	UnionRects (const RectF &a, const RectF &b)
RectF	SubtractRects (const RectF &a, const RectF &b)
RectF	BoundingRect (const PointF &p1, const PointF &p2)
bool	operator== (const RectF &lhs, const RectF &rhs)
bool	operator!= (const RectF &lhs, const RectF &rhs)
RectF	operator+ (const RectF &lhs, const Vector2dF &rhs)
RectF	operator- (const RectF &lhs, const Vector2dF &rhs)
RectF	operator+ (const Vector2dF &lhs, const RectF &rhs)
RectF	ScaleRect (const RectF &r, float x_scale, float y_scale)
RectF	ScaleRect (const RectF &r, float scale)
void	PrintTo (const RectF &rect, ::std::ostream *os)
template<typename T , size_t N>
constexpr size_t	size (const T(&array)[N]) noexcept
	TEST (RectTest, Contains)
	TEST (RectTest, Intersects)
	TEST (RectTest, Intersect)
	TEST (RectTest, Union)
	TEST (RectTest, Equals)
	TEST (RectTest, AdjustToFit)
	TEST (RectTest, Subtract)
	TEST (RectTest, IsEmpty)
	TEST (RectTest, SplitVertically)
	TEST (RectTest, CenterPoint)
	TEST (RectTest, CenterPointF)
	TEST (RectTest, SharesEdgeWith)
	TEST (RectTest, ScaleRect)
	TEST (RectTest, ToEnclosedRect)
	TEST (RectTest, ToEnclosingRect)
	TEST (RectTest, ToEnclosingRectIgnoringError)
	TEST (RectTest, ToNearestRect)
	TEST (RectTest, ToFlooredRect)
	TEST (RectTest, ScaleToEnclosedRect)
	TEST (RectTest, ScaleToEnclosingRect)
	TEST (RectTest, ToRectF)
	TEST (RectTest, BoundingRect)
	TEST (RectTest, IsExpressibleAsRect)
	TEST (RectTest, Offset)
	TEST (RectTest, Corners)
	TEST (RectTest, Centers)
	TEST (RectTest, Transpose)
	TEST (RectTest, ManhattanDistanceToPoint)
	TEST (RectTest, ManhattanInternalDistance)
	TEST (RectTest, IntegerOverflow)
	TEST (RectTest, ScaleToEnclosingRectSafe)
Size	ScaleToCeiledSize (const Size &size, float x_scale, float y_scale)
Size	ScaleToCeiledSize (const Size &size, float scale)
Size	ScaleToFlooredSize (const Size &size, float x_scale, float y_scale)
Size	ScaleToFlooredSize (const Size &size, float scale)
Size	ScaleToRoundedSize (const Size &size, float x_scale, float y_scale)
Size	ScaleToRoundedSize (const Size &size, float scale)
bool	operator== (const Size &lhs, const Size &rhs)
bool	operator!= (const Size &lhs, const Size &rhs)
Size	operator+ (Size lhs, const Size &rhs)
Size	operator- (Size lhs, const Size &rhs)
void	PrintTo (const Size &size, ::std::ostream *os)
Size	ToFlooredSize (const SizeF &size)
Size	ToCeiledSize (const SizeF &size)
Size	ToRoundedSize (const SizeF &size)
SizeF	ScaleSize (const SizeF &s, float x_scale, float y_scale)
bool	operator== (const SizeF &lhs, const SizeF &rhs)
bool	operator!= (const SizeF &lhs, const SizeF &rhs)
SizeF	ScaleSize (const SizeF &p, float scale)
void	PrintTo (const SizeF &size, ::std::ostream *os)
	TEST (SizeTest, ToSizeF)
	TEST (SizeTest, ToFlooredSize)
	TEST (SizeTest, ToCeiledSize)
	TEST (SizeTest, ToRoundedSize)
	TEST (SizeTest, ClampSize)
	TEST (SizeTest, ClampSizeF)
	TEST (SizeTest, Enlarge)
	TEST (SizeTest, IntegerOverflow)
	TEST (SizeTest, TrivialDimensionTests)
	TEST (SizeTest, ClampsToZero)
	TEST (SizeTest, ConsistentClamping)
	TEST (SizeTest, StaysSmall)
	TEST (SizeTest, OperatorAddSub)
	TEST (SizeTest, OperatorAddOverflow)
	TEST (SizeTest, OperatorSubClampAtZero)
	TEST (SizeTest, OperatorCompare)
constexpr Vector2d	operator- (const Vector2d &v)
Vector2d	operator+ (const Vector2d &lhs, const Vector2d &rhs)
Vector2d	operator- (const Vector2d &lhs, const Vector2d &rhs)
void	PrintTo (const Vector2d &vector, ::std::ostream *os)
Vector2d	ToFlooredVector2d (const Vector2dF &vector2d)
Vector2d	ToCeiledVector2d (const Vector2dF &vector2d)
Vector2d	ToRoundedVector2d (const Vector2dF &vector2d)
double	CrossProduct (const Vector2dF &lhs, const Vector2dF &rhs)
double	DotProduct (const Vector2dF &lhs, const Vector2dF &rhs)
Vector2dF	ScaleVector2d (const Vector2dF &v, float x_scale, float y_scale)
constexpr bool	operator== (const Vector2dF &lhs, const Vector2dF &rhs)
constexpr bool	operator!= (const Vector2dF &lhs, const Vector2dF &rhs)
constexpr Vector2dF	operator- (const Vector2dF &v)
Vector2dF	operator+ (const Vector2dF &lhs, const Vector2dF &rhs)
Vector2dF	operator- (const Vector2dF &lhs, const Vector2dF &rhs)
Vector2dF	ScaleVector2d (const Vector2dF &v, float scale)
void	PrintTo (const Vector2dF &vector, ::std::ostream *os)
	TEST (Vector2dTest, ConversionToFloat)
	TEST (Vector2dTest, IsZero)
	TEST (Vector2dTest, Add)
	TEST (Vector2dTest, Negative)
	TEST (Vector2dTest, Scale)
	TEST (Vector2dTest, Length)
	TEST (Vector2dTest, ClampVector2d)
	TEST (Vector2dTest, ClampVector2dF)
	TEST (Vector2dTest, IntegerOverflow)
GFX_EXPORT NSRect	ScreenRectToNSRect (const Rect &rect)
GFX_EXPORT Rect	ScreenRectFromNSRect (const NSRect &point)
GFX_EXPORT NSPoint	ScreenPointToNSPoint (const Point &point)
GFX_EXPORT Point	ScreenPointFromNSPoint (const NSPoint &point)
std::ostream &	operator<< (std::ostream &os, const Range &range)
::testing::AssertionResult	AssertPointFloatEqual (const char *lhs_expr, const char *rhs_expr, const PointF &lhs, const PointF &rhs)
::testing::AssertionResult	AssertRectFloatEqual (const char *lhs_expr, const char *rhs_expr, const RectF &lhs, const RectF &rhs)
::testing::AssertionResult	AssertSizeFFloatEqual (const char *lhs_expr, const char *rhs_expr, const SizeF &lhs, const SizeF &rhs)
void	PrintTo (const Transform &transform, ::std::ostream *os)
::testing::AssertionResult	AssertAxisTransform2dFloatEqual (const char *lhs_expr, const char *rhs_expr, const AxisTransform2d &lhs, const AxisTransform2d &rhs)
::testing::AssertionResult	AssertBoxFloatEqual (const char *lhs_expr, const char *rhs_expr, const BoxF &lhs, const BoxF &rhs)

Variables
const gfx::NativeCursor	kNullCursor = static_cast<gfx::NativeCursor>(nullptr)

Typedef Documentation

NativeViewAccessible

typedef UnimplementedNativeViewAccessible* gfx::NativeViewAccessible

Definition at line 225 of file native_widget_types.h.

NativeViewId

typedef intptr_t gfx::NativeViewId

Definition at line 241 of file native_widget_types.h.

UnimplementedNativeViewAccessible

typedef struct _UnimplementedNativeViewAccessible gfx::UnimplementedNativeViewAccessible

Definition at line 224 of file native_widget_types.h.

Function Documentation

AdjustAlongAxis() [1/2]

static void gfx::AdjustAlongAxis ( float  dst_origin, float  dst_size, float *  origin, float *  size  )

static

Definition at line 24 of file rect_f.cc.

                                         {
  *size = std::min(dst_size, *size);
  if (*origin < dst_origin)
    *origin = dst_origin;
  else
    *origin = std::min(dst_origin + dst_size, *origin + *size) - *size;
}

AdjustAlongAxis() [2/2]

void gfx::AdjustAlongAxis	(	int	dst_origin,
		int	dst_size,
		int *	origin,
		int *	size
	)

Definition at line 49 of file rect.cc.

                                                                           {
  *size = std::min(dst_size, *size);
  if (*origin < dst_origin)
    *origin = dst_origin;
  else
    *origin = std::min(dst_origin + dst_size, *origin + *size) - *size;
}

AssertAxisTransform2dFloatEqual()

::testing::AssertionResult gfx::AssertAxisTransform2dFloatEqual	(	const char *	lhs_expr,
		const char *	rhs_expr,
		const AxisTransform2d &	lhs,
		const AxisTransform2d &	rhs
	)

AssertBoxFloatEqual()

::testing::AssertionResult gfx::AssertBoxFloatEqual	(	const char *	lhs_expr,
		const char *	rhs_expr,
		const BoxF &	lhs,
		const BoxF &	rhs
	)

AssertPointFloatEqual()

testing::AssertionResult gfx::AssertPointFloatEqual	(	const char *	lhs_expr,
		const char *	rhs_expr,
		const PointF &	lhs,
		const PointF &	rhs
	)

Definition at line 33 of file gfx_util.cc.

                                                                    {
  if (FloatAlmostEqual(lhs.x(), rhs.x()) &&
      FloatAlmostEqual(lhs.y(), rhs.y())) {
    return ::testing::AssertionSuccess();
  }
  return ::testing::AssertionFailure()
         << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
         << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
}

AssertRectFloatEqual()

testing::AssertionResult gfx::AssertRectFloatEqual	(	const char *	lhs_expr,
		const char *	rhs_expr,
		const RectF &	lhs,
		const RectF &	rhs
	)

Definition at line 46 of file gfx_util.cc.

                                                                  {
  if (FloatAlmostEqual(lhs.x(), rhs.x()) &&
      FloatAlmostEqual(lhs.y(), rhs.y()) &&
      FloatAlmostEqual(lhs.width(), rhs.width()) &&
      FloatAlmostEqual(lhs.height(), rhs.height())) {
    return ::testing::AssertionSuccess();
  }
  return ::testing::AssertionFailure()
         << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
         << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
}

AssertSizeFFloatEqual()

testing::AssertionResult gfx::AssertSizeFFloatEqual	(	const char *	lhs_expr,
		const char *	rhs_expr,
		const SizeF &	lhs,
		const SizeF &	rhs
	)

Definition at line 61 of file gfx_util.cc.

                                                                   {
  if (FloatAlmostEqual(lhs.width(), rhs.width()) &&
      FloatAlmostEqual(lhs.height(), rhs.height())) {
    return ::testing::AssertionSuccess();
  }
  return ::testing::AssertionFailure()
         << "Value of: " << rhs_expr << "\n  Actual: " << rhs.ToString()
         << "\nExpected: " << lhs_expr << "\nWhich is: " << lhs.ToString();
}

BoundingRect() [1/2]

GFX_EXPORT Rect gfx::BoundingRect	(	const Point &	p1,
		const Point &	p2
	)

Definition at line 336 of file rect.cc.

                                                    {
  Rect result;
  result.SetByBounds(std::min(p1.x(), p2.x()), std::min(p1.y(), p2.y()),
                     std::max(p1.x(), p2.x()), std::max(p1.y(), p2.y()));
  return result;
}

BoundingRect() [2/2]

GFX_EXPORT RectF gfx::BoundingRect	(	const PointF &	p1,
		const PointF &	p2
	)

Definition at line 254 of file rect_f.cc.

                                                       {
  float rx = std::min(p1.x(), p2.x());
  float ry = std::min(p1.y(), p2.y());
  float rr = std::max(p1.x(), p2.x());
  float rb = std::max(p1.y(), p2.y());
  return RectF(rx, ry, rr - rx, rb - ry);
}

CrossProduct()

GFX_EXPORT double gfx::CrossProduct	(	const Vector2dF &	lhs,
		const Vector2dF &	rhs
	)

Definition at line 44 of file vector2d_f.cc.

                                                                {
  return static_cast<double>(lhs.x()) * rhs.y() -
         static_cast<double>(lhs.y()) * rhs.x();
}

DotProduct()

GFX_EXPORT double gfx::DotProduct	(	const Vector2dF &	lhs,
		const Vector2dF &	rhs
	)

Definition at line 49 of file vector2d_f.cc.

                                                              {
  return static_cast<double>(lhs.x()) * rhs.x() +
         static_cast<double>(lhs.y()) * rhs.y();
}

IntersectRects() [1/2]

GFX_EXPORT Rect gfx::IntersectRects	(	const Rect &	a,
		const Rect &	b
	)

Definition at line 318 of file rect.cc.

                                                  {
  Rect result = a;
  result.Intersect(b);
  return result;
}

IntersectRects() [2/2]

GFX_EXPORT RectF gfx::IntersectRects	(	const RectF &	a,
		const RectF &	b
	)

Definition at line 236 of file rect_f.cc.

                                                     {
  RectF result = a;
  result.Intersect(b);
  return result;
}

IsNearestRectWithinDistance()

GFX_EXPORT bool gfx::IsNearestRectWithinDistance	(	const gfx::RectF &	rect,
		float	distance
	)

Definition at line 94 of file rect_conversions.cc.

                                                                       {
  float float_min_x = rect.x();
  float float_min_y = rect.y();
  float float_max_x = rect.right();
  float float_max_y = rect.bottom();
 
  int min_x = base::ClampRound(float_min_x);
  int min_y = base::ClampRound(float_min_y);
  int max_x = base::ClampRound(float_max_x);
  int max_y = base::ClampRound(float_max_y);
 
  return (std::abs(min_x - float_min_x) < distance) &&
         (std::abs(min_y - float_min_y) < distance) &&
         (std::abs(max_x - float_max_x) < distance) &&
         (std::abs(max_y - float_max_y) < distance);
}

operator!=() [1/7]

bool gfx::operator!= ( const Point &  lhs, const Point &  rhs  )

inline

Definition at line 100 of file point.h.

                                                           {
  return !(lhs == rhs);
}

operator!=() [2/7]

bool gfx::operator!= ( const PointF &  lhs, const PointF &  rhs  )

inline

Definition at line 87 of file point_f.h.

                                                             {
  return !(lhs == rhs);
}

operator!=() [3/7]

bool gfx::operator!= ( const Rect &  lhs, const Rect &  rhs  )

inline

Definition at line 243 of file rect.h.

                                                         {
  return !(lhs == rhs);
}

operator!=() [4/7]

bool gfx::operator!= ( const RectF &  lhs, const RectF &  rhs  )

inline

Definition at line 199 of file rect_f.h.

                                                           {
  return !(lhs == rhs);
}

operator!=() [5/7]

bool gfx::operator!= ( const Size &  lhs, const Size &  rhs  )

inline

Definition at line 83 of file size.h.

                                                         {
  return !(lhs == rhs);
}

operator!=() [6/7]

bool gfx::operator!= ( const SizeF &  lhs, const SizeF &  rhs  )

inline

Definition at line 69 of file size_f.h.

                                                           {
  return !(lhs == rhs);
}

operator!=() [7/7]

constexpr bool gfx::operator!= ( const Vector2dF &  lhs, const Vector2dF &  rhs  )

inlineconstexpr

Definition at line 75 of file vector2d_f.h.

                                                                             {
  return !(lhs == rhs);
}

operator+() [1/11]

Point gfx::operator+ ( const Point &  lhs, const Vector2d &  rhs  )

inline

Definition at line 104 of file point.h.

                                                              {
  Point result(lhs);
  result += rhs;
  return result;
}

operator+() [2/11]

PointF gfx::operator+ ( const PointF &  lhs, const Vector2dF &  rhs  )

inline

Definition at line 91 of file point_f.h.

                                                                 {
  PointF result(lhs);
  result += rhs;
  return result;
}

operator+() [3/11]

GFX_EXPORT Rect gfx::operator+	(	const Rect &	lhs,
		const Vector2d &	rhs
	)

Definition at line 306 of file rect.cc.

                                                     {
  Rect result(lhs);
  result += rhs;
  return result;
}

operator+() [4/11]

RectF gfx::operator+ ( const RectF &  lhs, const Vector2dF &  rhs  )

inline

Definition at line 203 of file rect_f.h.

                                                               {
  return RectF(lhs.x() + rhs.x(), lhs.y() + rhs.y(), lhs.width(), lhs.height());
}

operator+() [5/11]

Rect gfx::operator+ ( const Vector2d &  lhs, const Rect &  rhs  )

inline

Definition at line 250 of file rect.h.

                                                            {
  return rhs + lhs;
}

operator+() [6/11]

Vector2d gfx::operator+ ( const Vector2d &  lhs, const Vector2d &  rhs  )

inline

Definition at line 79 of file vector2d.h.

                                                                    {
  Vector2d result = lhs;
  result.Add(rhs);
  return result;
}

operator+() [7/11]

RectF gfx::operator+ ( const Vector2dF &  lhs, const RectF &  rhs  )

inline

Definition at line 211 of file rect_f.h.

                                                               {
  return rhs + lhs;
}

operator+() [8/11]

Vector2dF gfx::operator+ ( const Vector2dF &  lhs, const Vector2dF &  rhs  )

inline

Definition at line 83 of file vector2d_f.h.

                                                                       {
  Vector2dF result = lhs;
  result.Add(rhs);
  return result;
}

operator+() [9/11]

Insets gfx::operator+ ( Insets  lhs, const Insets &  rhs  )

inline

Definition at line 175 of file insets.h.

                                                       {
  lhs += rhs;
  return lhs;
}

operator+() [10/11]

InsetsF gfx::operator+ ( InsetsF  lhs, const InsetsF &  rhs  )

inline

Definition at line 91 of file insets_f.h.

                                                          {
  lhs += rhs;
  return lhs;
}

operator+() [11/11]

Size gfx::operator+ ( Size  lhs, const Size &  rhs  )

inline

Definition at line 87 of file size.h.

                                                 {
  lhs += rhs;
  return lhs;
}

operator-() [1/13]

Vector2d gfx::operator- ( const Point &  lhs, const Point &  rhs  )

inline

Definition at line 116 of file point.h.

                                                              {
  return Vector2d(base::ClampSub(lhs.x(), rhs.x()), base::ClampSub(lhs.y(), rhs.y()));
}

operator-() [2/13]

Point gfx::operator- ( const Point &  lhs, const Vector2d &  rhs  )

inline

Definition at line 110 of file point.h.

                                                              {
  Point result(lhs);
  result -= rhs;
  return result;
}

operator-() [3/13]

Vector2dF gfx::operator- ( const PointF &  lhs, const PointF &  rhs  )

inline

Definition at line 103 of file point_f.h.

                                                                 {
  return Vector2dF(lhs.x() - rhs.x(), lhs.y() - rhs.y());
}

operator-() [4/13]

PointF gfx::operator- ( const PointF &  lhs, const Vector2dF &  rhs  )

inline

Definition at line 97 of file point_f.h.

                                                                 {
  PointF result(lhs);
  result -= rhs;
  return result;
}

operator-() [5/13]

GFX_EXPORT Rect gfx::operator-	(	const Rect &	lhs,
		const Vector2d &	rhs
	)

Definition at line 312 of file rect.cc.

                                                     {
  Rect result(lhs);
  result -= rhs;
  return result;
}

operator-() [6/13]

RectF gfx::operator- ( const RectF &  lhs, const Vector2dF &  rhs  )

inline

Definition at line 207 of file rect_f.h.

                                                               {
  return RectF(lhs.x() - rhs.x(), lhs.y() - rhs.y(), lhs.width(), lhs.height());
}

operator-() [7/13]

Vector2d gfx::operator- ( const Vector2d &  lhs, const Vector2d &  rhs  )

inline

Definition at line 85 of file vector2d.h.

                                                                    {
  Vector2d result = lhs;
  result.Add(-rhs);
  return result;
}

operator-() [8/13]

constexpr Vector2d gfx::operator- ( const Vector2d &  v )

inlineconstexpr

Definition at line 75 of file vector2d.h.

                                                       {
  return Vector2d(-v.x(), -v.y());
}

operator-() [9/13]

Vector2dF gfx::operator- ( const Vector2dF &  lhs, const Vector2dF &  rhs  )

inline

Definition at line 89 of file vector2d_f.h.

                                                                       {
  Vector2dF result = lhs;
  result.Add(-rhs);
  return result;
}

operator-() [10/13]

constexpr Vector2dF gfx::operator- ( const Vector2dF &  v )

inlineconstexpr

Definition at line 79 of file vector2d_f.h.

                                                         {
  return Vector2dF(-v.x(), -v.y());
}

operator-() [11/13]

Insets gfx::operator- ( Insets  lhs, const Insets &  rhs  )

inline

Definition at line 180 of file insets.h.

                                                       {
  lhs -= rhs;
  return lhs;
}

operator-() [12/13]

InsetsF gfx::operator- ( InsetsF  lhs, const InsetsF &  rhs  )

inline

Definition at line 96 of file insets_f.h.

                                                          {
  lhs -= rhs;
  return lhs;
}

operator-() [13/13]

Size gfx::operator- ( Size  lhs, const Size &  rhs  )

inline

Definition at line 92 of file size.h.

                                                 {
  lhs -= rhs;
  return lhs;
}

operator<<()

GFX_RANGE_EXPORT std::ostream & gfx::operator<<	(	std::ostream &	os,
		const Range &	range
	)

Definition at line 18 of file range.cc.

                                                           {
  return os << range.ToString();
}

operator==() [1/7]

bool gfx::operator== ( const Point &  lhs, const Point &  rhs  )

inline

Definition at line 96 of file point.h.

                                                           {
  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
}

operator==() [2/7]

bool gfx::operator== ( const PointF &  lhs, const PointF &  rhs  )

inline

Definition at line 83 of file point_f.h.

                                                             {
  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
}

operator==() [3/7]

bool gfx::operator== ( const Rect &  lhs, const Rect &  rhs  )

inline

Definition at line 239 of file rect.h.

                                                         {
  return lhs.origin() == rhs.origin() && lhs.size() == rhs.size();
}

operator==() [4/7]

bool gfx::operator== ( const RectF &  lhs, const RectF &  rhs  )

inline

Definition at line 195 of file rect_f.h.

                                                           {
  return lhs.origin() == rhs.origin() && lhs.size() == rhs.size();
}

operator==() [5/7]

bool gfx::operator== ( const Size &  lhs, const Size &  rhs  )

inline

Definition at line 79 of file size.h.

                                                         {
  return lhs.width() == rhs.width() && lhs.height() == rhs.height();
}

operator==() [6/7]

bool gfx::operator== ( const SizeF &  lhs, const SizeF &  rhs  )

inline

Definition at line 65 of file size_f.h.

                                                           {
  return lhs.width() == rhs.width() && lhs.height() == rhs.height();
}

operator==() [7/7]

constexpr bool gfx::operator== ( const Vector2dF &  lhs, const Vector2dF &  rhs  )

inlineconstexpr

Definition at line 71 of file vector2d_f.h.

                                                                             {
  return lhs.x() == rhs.x() && lhs.y() == rhs.y();
}

PointAtOffsetFromOrigin() [1/2]

Point gfx::PointAtOffsetFromOrigin ( const Vector2d &  offset_from_origin )

inline

Definition at line 120 of file point.h.

                                                                         {
  return Point(offset_from_origin.x(), offset_from_origin.y());
}

PointAtOffsetFromOrigin() [2/2]

PointF gfx::PointAtOffsetFromOrigin ( const Vector2dF &  offset_from_origin )

inline

Definition at line 107 of file point_f.h.

                                                                           {
  return PointF(offset_from_origin.x(), offset_from_origin.y());
}

PrintTo() [1/9]

void gfx::PrintTo	(	const Point &	point,
		::std::ostream *	os
	)

Definition at line 74 of file gfx_util.cc.

                                                 {
  *os << point.ToString();
}

PrintTo() [2/9]

void gfx::PrintTo	(	const PointF &	point,
		::std::ostream *	os
	)

Definition at line 78 of file gfx_util.cc.

                                                  {
  *os << point.ToString();
}

PrintTo() [3/9]

void gfx::PrintTo	(	const Rect &	rect,
		::std::ostream *	os
	)

Definition at line 82 of file gfx_util.cc.

                                               {
  *os << rect.ToString();
}

PrintTo() [4/9]

void gfx::PrintTo	(	const RectF &	rect,
		::std::ostream *	os
	)

Definition at line 86 of file gfx_util.cc.

                                                {
  *os << rect.ToString();
}

PrintTo() [5/9]

void gfx::PrintTo	(	const Size &	size,
		::std::ostream *	os
	)

Definition at line 90 of file gfx_util.cc.

                                               {
  *os << size.ToString();
}

PrintTo() [6/9]

void gfx::PrintTo	(	const SizeF &	size,
		::std::ostream *	os
	)

Definition at line 94 of file gfx_util.cc.

                                                {
  *os << size.ToString();
}

PrintTo() [7/9]

void gfx::PrintTo	(	const Transform &	transform,
		::std::ostream *	os
	)

Definition at line 98 of file gfx_util.cc.

                                                         {
  *os << transform.ToString();
}

PrintTo() [8/9]

void gfx::PrintTo	(	const Vector2d &	vector,
		::std::ostream *	os
	)

Definition at line 102 of file gfx_util.cc.

                                                     {
  *os << vector.ToString();
}

PrintTo() [9/9]

void gfx::PrintTo	(	const Vector2dF &	vector,
		::std::ostream *	os
	)

Definition at line 106 of file gfx_util.cc.

                                                      {
  *os << vector.ToString();
}

SaturatedClampRange()

static void gfx::SaturatedClampRange ( int  min, int  max, int *  origin, int *  span  )

static

Definition at line 63 of file rect.cc.

                                                                          {
  if (max < min) {
    *span = 0;
    *origin = min;
    return;
  }
 
  int effective_span = base::ClampSub(max, min);
  int span_loss = base::ClampSub(max, min + effective_span);
 
  // If the desired width is within the limits of ints, we can just
  // use the simple computations to represent the range precisely.
  if (span_loss == 0) {
    *span = effective_span;
    *origin = min;
    return;
  }
 
  // Now we have to approximate. If one of min or max is close enough
  // to zero we choose to represent that one precisely. The other side is
  // probably practically "infinite", so we move it.
  constexpr unsigned kMaxDimension = std::numeric_limits<int>::max() / 2;
  if (base::SafeUnsignedAbs(max) < kMaxDimension) {
    // Maintain origin + span == max.
    *span = effective_span;
    *origin = max - effective_span;
  } else if (base::SafeUnsignedAbs(min) < kMaxDimension) {
    // Maintain origin == min.
    *span = effective_span;
    *origin = min;
  } else {
    // Both are big, so keep the center.
    *span = effective_span;
    *origin = min + span_loss / 2;
  }
}

ScalePoint() [1/2]

PointF gfx::ScalePoint ( const PointF &  p, float  scale  )

inline

Definition at line 113 of file point_f.h.

                                                       {
  return ScalePoint(p, scale, scale);
}

ScalePoint() [2/2]

GFX_EXPORT PointF gfx::ScalePoint	(	const PointF &	p,
		float	x_scale,
		float	y_scale
	)

Definition at line 25 of file point_f.cc.

                                                                 {
  PointF scaled_p(p);
  scaled_p.Scale(x_scale, y_scale);
  return scaled_p;
}

ScaleRect() [1/2]

RectF gfx::ScaleRect ( const RectF &  r, float  scale  )

inline

Definition at line 223 of file rect_f.h.

                                                    {
  return ScaleRect(r, scale, scale);
}

ScaleRect() [2/2]

RectF gfx::ScaleRect ( const RectF &  r, float  x_scale, float  y_scale  )

inline

Definition at line 219 of file rect_f.h.

                                                                     {
  return RectF(r.x() * x_scale, r.y() * y_scale, r.width() * x_scale, r.height() * y_scale);
}

ScaleSize() [1/2]

SizeF gfx::ScaleSize ( const SizeF &  p, float  scale  )

inline

Definition at line 75 of file size_f.h.

                                                    {
  return ScaleSize(p, scale, scale);
}

ScaleSize() [2/2]

GFX_EXPORT SizeF gfx::ScaleSize	(	const SizeF &	s,
		float	x_scale,
		float	y_scale
	)

Definition at line 33 of file size_f.cc.

                                                              {
  SizeF scaled_s(s);
  scaled_s.Scale(x_scale, y_scale);
  return scaled_s;
}

ScaleToCeiledPoint() [1/2]

GFX_EXPORT Point gfx::ScaleToCeiledPoint	(	const Point &	point,
		float	scale
	)

Definition at line 73 of file point.cc.

                                                          {
  if (scale == 1.f)
    return point;
  return ToCeiledPoint(ScalePoint(gfx::PointF(point), scale, scale));
}

ScaleToCeiledPoint() [2/2]

GFX_EXPORT Point gfx::ScaleToCeiledPoint	(	const Point &	point,
		float	x_scale,
		float	y_scale
	)

Definition at line 67 of file point.cc.

                                                                           {
  if (x_scale == 1.f && y_scale == 1.f)
    return point;
  return ToCeiledPoint(ScalePoint(gfx::PointF(point), x_scale, y_scale));
}

ScaleToCeiledSize() [1/2]

GFX_EXPORT Size gfx::ScaleToCeiledSize	(	const Size &	size,
		float	scale
	)

Definition at line 90 of file size.cc.

                                                      {
  if (scale == 1.f)
    return size;
  return ToCeiledSize(ScaleSize(gfx::SizeF(size), scale, scale));
}

ScaleToCeiledSize() [2/2]

GFX_EXPORT Size gfx::ScaleToCeiledSize	(	const Size &	size,
		float	x_scale,
		float	y_scale
	)

Definition at line 84 of file size.cc.

                                                                       {
  if (x_scale == 1.f && y_scale == 1.f)
    return size;
  return ToCeiledSize(ScaleSize(gfx::SizeF(size), x_scale, y_scale));
}

ScaleToEnclosedRect() [1/2]

Rect gfx::ScaleToEnclosedRect ( const Rect &  rect, float  scale  )

inline

Definition at line 323 of file rect.h.

                                                               {
  return ScaleToEnclosedRect(rect, scale, scale);
}

ScaleToEnclosedRect() [2/2]

Rect gfx::ScaleToEnclosedRect ( const Rect &  rect, float  x_scale, float  y_scale  )

inline

Definition at line 309 of file rect.h.

                                                                                {
  if (x_scale == 1.f && y_scale == 1.f)
    return rect;
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::ceil(rect.x() * x_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::ceil(rect.y() * y_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::floor(rect.right() * x_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::floor(rect.bottom() * y_scale)));
  int x = static_cast<int>(std::ceil(rect.x() * x_scale));
  int y = static_cast<int>(std::ceil(rect.y() * y_scale));
  int r = rect.width() == 0 ? x : static_cast<int>(std::floor(rect.right() * x_scale));
  int b = rect.height() == 0 ? y : static_cast<int>(std::floor(rect.bottom() * y_scale));
  return Rect(x, y, r - x, b - y);
}

ScaleToEnclosingRect() [1/2]

Rect gfx::ScaleToEnclosingRect ( const Rect &  rect, float  scale  )

inline

Definition at line 287 of file rect.h.

                                                                {
  return ScaleToEnclosingRect(rect, scale, scale);
}

ScaleToEnclosingRect() [2/2]

Rect gfx::ScaleToEnclosingRect ( const Rect &  rect, float  x_scale, float  y_scale  )

inline

Definition at line 269 of file rect.h.

                                                                                 {
  if (x_scale == 1.f && y_scale == 1.f)
    return rect;
  // These next functions cast instead of using e.g. base::ClampFloor() because
  // we haven't checked to ensure that the clamping behavior of the helper
  // functions doesn't degrade performance, and callers shouldn't be passing
  // values that cause overflow anyway.
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::floor(rect.x() * x_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::floor(rect.y() * y_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::ceil(rect.right() * x_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::ceil(rect.bottom() * y_scale)));
  int x = static_cast<int>(std::floor(rect.x() * x_scale));
  int y = static_cast<int>(std::floor(rect.y() * y_scale));
  int r = rect.width() == 0 ? x : static_cast<int>(std::ceil(rect.right() * x_scale));
  int b = rect.height() == 0 ? y : static_cast<int>(std::ceil(rect.bottom() * y_scale));
  return Rect(x, y, r - x, b - y);
}

ScaleToEnclosingRectSafe() [1/2]

Rect gfx::ScaleToEnclosingRectSafe ( const Rect &  rect, float  scale  )

inline

Definition at line 305 of file rect.h.

                                                                    {
  return ScaleToEnclosingRectSafe(rect, scale, scale);
}

ScaleToEnclosingRectSafe() [2/2]

Rect gfx::ScaleToEnclosingRectSafe ( const Rect &  rect, float  x_scale, float  y_scale  )

inline

Definition at line 295 of file rect.h.

                                                                                     {
  if (x_scale == 1.f && y_scale == 1.f)
    return rect;
  int x = base::ClampFloor(rect.x() * x_scale);
  int y = base::ClampFloor(rect.y() * y_scale);
  int w = base::ClampCeil(rect.width() * x_scale);
  int h = base::ClampCeil(rect.height() * y_scale);
  return Rect(x, y, w, h);
}

ScaleToFlooredPoint() [1/2]

GFX_EXPORT Point gfx::ScaleToFlooredPoint	(	const Point &	point,
		float	scale
	)

Definition at line 85 of file point.cc.

                                                           {
  if (scale == 1.f)
    return point;
  return ToFlooredPoint(ScalePoint(gfx::PointF(point), scale, scale));
}

ScaleToFlooredPoint() [2/2]

GFX_EXPORT Point gfx::ScaleToFlooredPoint	(	const Point &	point,
		float	x_scale,
		float	y_scale
	)

Definition at line 79 of file point.cc.

                                                                            {
  if (x_scale == 1.f && y_scale == 1.f)
    return point;
  return ToFlooredPoint(ScalePoint(gfx::PointF(point), x_scale, y_scale));
}

ScaleToFlooredSize() [1/2]

GFX_EXPORT Size gfx::ScaleToFlooredSize	(	const Size &	size,
		float	scale
	)

Definition at line 102 of file size.cc.

                                                       {
  if (scale == 1.f)
    return size;
  return ToFlooredSize(ScaleSize(gfx::SizeF(size), scale, scale));
}

ScaleToFlooredSize() [2/2]

GFX_EXPORT Size gfx::ScaleToFlooredSize	(	const Size &	size,
		float	x_scale,
		float	y_scale
	)

Definition at line 96 of file size.cc.

                                                                        {
  if (x_scale == 1.f && y_scale == 1.f)
    return size;
  return ToFlooredSize(ScaleSize(gfx::SizeF(size), x_scale, y_scale));
}

ScaleToRoundedPoint() [1/2]

GFX_EXPORT Point gfx::ScaleToRoundedPoint	(	const Point &	point,
		float	scale
	)

Definition at line 97 of file point.cc.

                                                           {
  if (scale == 1.f)
    return point;
  return ToRoundedPoint(ScalePoint(gfx::PointF(point), scale, scale));
}

ScaleToRoundedPoint() [2/2]

GFX_EXPORT Point gfx::ScaleToRoundedPoint	(	const Point &	point,
		float	x_scale,
		float	y_scale
	)

Definition at line 91 of file point.cc.

                                                                            {
  if (x_scale == 1.f && y_scale == 1.f)
    return point;
  return ToRoundedPoint(ScalePoint(gfx::PointF(point), x_scale, y_scale));
}

ScaleToRoundedRect() [1/2]

Rect gfx::ScaleToRoundedRect ( const Rect &  rect, float  scale  )

inline

Definition at line 350 of file rect.h.

                                                              {
  return ScaleToRoundedRect(rect, scale, scale);
}

ScaleToRoundedRect() [2/2]

Rect gfx::ScaleToRoundedRect ( const Rect &  rect, float  x_scale, float  y_scale  )

inline

Definition at line 333 of file rect.h.

                                                                               {
  if (x_scale == 1.f && y_scale == 1.f)
    return rect;
 
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::round(rect.x() * x_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::round(rect.y() * y_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::round(rect.right() * x_scale)));
  BASE_DCHECK(base::IsValueInRangeForNumericType<int>(std::round(rect.bottom() * y_scale)));
 
  int x = static_cast<int>(std::round(rect.x() * x_scale));
  int y = static_cast<int>(std::round(rect.y() * y_scale));
  int r = rect.width() == 0 ? x : static_cast<int>(std::round(rect.right() * x_scale));
  int b = rect.height() == 0 ? y : static_cast<int>(std::round(rect.bottom() * y_scale));
 
  return Rect(x, y, r - x, b - y);
}

ScaleToRoundedSize() [1/2]

GFX_EXPORT Size gfx::ScaleToRoundedSize	(	const Size &	size,
		float	scale
	)

Definition at line 114 of file size.cc.

                                                       {
  if (scale == 1.f)
    return size;
  return ToRoundedSize(ScaleSize(gfx::SizeF(size), scale, scale));
}

ScaleToRoundedSize() [2/2]

GFX_EXPORT Size gfx::ScaleToRoundedSize	(	const Size &	size,
		float	x_scale,
		float	y_scale
	)

Definition at line 108 of file size.cc.

                                                                        {
  if (x_scale == 1.f && y_scale == 1.f)
    return size;
  return ToRoundedSize(ScaleSize(gfx::SizeF(size), x_scale, y_scale));
}

ScaleVector2d() [1/2]

Vector2dF gfx::ScaleVector2d ( const Vector2dF &  v, float  scale  )

inline

Definition at line 108 of file vector2d_f.h.

                                                                {
  return ScaleVector2d(v, scale, scale);
}

ScaleVector2d() [2/2]

GFX_EXPORT Vector2dF gfx::ScaleVector2d	(	const Vector2dF &	v,
		float	x_scale,
		float	y_scale
	)

Definition at line 54 of file vector2d_f.cc.

                                                                          {
  Vector2dF scaled_v(v);
  scaled_v.Scale(x_scale, y_scale);
  return scaled_v;
}

ScreenPointFromNSPoint()

Point gfx::ScreenPointFromNSPoint

(

const NSPoint &

point

)

Definition at line 38 of file coordinate_conversion.mm.

                                                   {
  return Point(point.x, PrimaryDisplayHeight() - point.y);
}

ScreenPointToNSPoint()

NSPoint gfx::ScreenPointToNSPoint

(

const Point &

point

)

Definition at line 34 of file coordinate_conversion.mm.

                                                 {
  return NSMakePoint(point.x(), PrimaryDisplayHeight() - point.y());
}

ScreenRectFromNSRect()

Rect gfx::ScreenRectFromNSRect

(

const NSRect &

point

)

Definition at line 29 of file coordinate_conversion.mm.

                                              {
  return Rect(rect.origin.x, PrimaryDisplayHeight() - rect.origin.y - rect.size.height,
              rect.size.width, rect.size.height);
}

ScreenRectToNSRect()

NSRect gfx::ScreenRectToNSRect

(

const Rect &

rect

)

Definition at line 24 of file coordinate_conversion.mm.

                                            {
  return NSMakeRect(rect.x(), PrimaryDisplayHeight() - rect.y() - rect.height(), rect.width(),
                    rect.height());
}

size()

template<typename T , size_t N>

constexpr size_t gfx::size ( const T(&)  array[N] )

constexprnoexcept

Definition at line 21 of file rect_unittest.cc.

                                                    {
  return N;
}

SubtractRects() [1/2]

GFX_EXPORT Rect gfx::SubtractRects	(	const Rect &	a,
		const Rect &	b
	)

Definition at line 330 of file rect.cc.

                                                 {
  Rect result = a;
  result.Subtract(b);
  return result;
}

SubtractRects() [2/2]

GFX_EXPORT RectF gfx::SubtractRects	(	const RectF &	a,
		const RectF &	b
	)

Definition at line 248 of file rect_f.cc.

                                                    {
  RectF result = a;
  result.Subtract(b);
  return result;
}

TEST() [1/67]

gfx::TEST	(	PointTest	,
		ClampPoint
	)

Definition at line 108 of file point_unittest.cc.

                            {
  Point a;
 
  a = Point(3, 5);
  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
  a.SetToMax(Point(2, 4));
  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
  a.SetToMax(Point(3, 5));
  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
  a.SetToMax(Point(4, 2));
  EXPECT_EQ(Point(4, 5).ToString(), a.ToString());
  a.SetToMax(Point(8, 10));
  EXPECT_EQ(Point(8, 10).ToString(), a.ToString());
 
  a.SetToMin(Point(9, 11));
  EXPECT_EQ(Point(8, 10).ToString(), a.ToString());
  a.SetToMin(Point(8, 10));
  EXPECT_EQ(Point(8, 10).ToString(), a.ToString());
  a.SetToMin(Point(11, 9));
  EXPECT_EQ(Point(8, 9).ToString(), a.ToString());
  a.SetToMin(Point(7, 11));
  EXPECT_EQ(Point(7, 9).ToString(), a.ToString());
  a.SetToMin(Point(3, 5));
  EXPECT_EQ(Point(3, 5).ToString(), a.ToString());
}

TEST() [2/67]

gfx::TEST	(	PointTest	,
		ClampPointF
	)

Definition at line 134 of file point_unittest.cc.

                             {
  PointF a;
 
  a = PointF(3.5f, 5.5f);
  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(PointF(2.5f, 4.5f));
  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(PointF(3.5f, 5.5f));
  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(PointF(4.5f, 2.5f));
  EXPECT_EQ(PointF(4.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(PointF(8.5f, 10.5f));
  EXPECT_EQ(PointF(8.5f, 10.5f).ToString(), a.ToString());
 
  a.SetToMin(PointF(9.5f, 11.5f));
  EXPECT_EQ(PointF(8.5f, 10.5f).ToString(), a.ToString());
  a.SetToMin(PointF(8.5f, 10.5f));
  EXPECT_EQ(PointF(8.5f, 10.5f).ToString(), a.ToString());
  a.SetToMin(PointF(11.5f, 9.5f));
  EXPECT_EQ(PointF(8.5f, 9.5f).ToString(), a.ToString());
  a.SetToMin(PointF(7.5f, 11.5f));
  EXPECT_EQ(PointF(7.5f, 9.5f).ToString(), a.ToString());
  a.SetToMin(PointF(3.5f, 5.5f));
  EXPECT_EQ(PointF(3.5f, 5.5f).ToString(), a.ToString());
}

TEST() [3/67]

gfx::TEST	(	PointTest	,
		IntegerOverflow
	)

Definition at line 176 of file point_unittest.cc.

                                 {
  int int_max = std::numeric_limits<int>::max();
  int int_min = std::numeric_limits<int>::min();
 
  Point max_point(int_max, int_max);
  Point min_point(int_min, int_min);
  Point test;
 
  test = Point();
  test.Offset(int_max, int_max);
  EXPECT_EQ(test, max_point);
 
  test = Point();
  test.Offset(int_min, int_min);
  EXPECT_EQ(test, min_point);
 
  test = Point(10, 20);
  test.Offset(int_max, int_max);
  EXPECT_EQ(test, max_point);
 
  test = Point(-10, -20);
  test.Offset(int_min, int_min);
  EXPECT_EQ(test, min_point);
 
  test = Point();
  test += Vector2d(int_max, int_max);
  EXPECT_EQ(test, max_point);
 
  test = Point();
  test += Vector2d(int_min, int_min);
  EXPECT_EQ(test, min_point);
 
  test = Point(10, 20);
  test += Vector2d(int_max, int_max);
  EXPECT_EQ(test, max_point);
 
  test = Point(-10, -20);
  test += Vector2d(int_min, int_min);
  EXPECT_EQ(test, min_point);
 
  test = Point();
  test -= Vector2d(int_max, int_max);
  EXPECT_EQ(test, Point(-int_max, -int_max));
 
  test = Point();
  test -= Vector2d(int_min, int_min);
  EXPECT_EQ(test, max_point);
 
  test = Point(10, 20);
  test -= Vector2d(int_min, int_min);
  EXPECT_EQ(test, max_point);
 
  test = Point(-10, -20);
  test -= Vector2d(int_max, int_max);
  EXPECT_EQ(test, min_point);
}

TEST() [4/67]

gfx::TEST	(	PointTest	,
		IsOrigin
	)

Definition at line 23 of file point_unittest.cc.

                          {
  EXPECT_FALSE(Point(1, 0).IsOrigin());
  EXPECT_FALSE(Point(0, 1).IsOrigin());
  EXPECT_FALSE(Point(1, 2).IsOrigin());
  EXPECT_FALSE(Point(-1, 0).IsOrigin());
  EXPECT_FALSE(Point(0, -1).IsOrigin());
  EXPECT_FALSE(Point(-1, -2).IsOrigin());
  EXPECT_TRUE(Point(0, 0).IsOrigin());
 
  EXPECT_FALSE(PointF(0.1f, 0).IsOrigin());
  EXPECT_FALSE(PointF(0, 0.1f).IsOrigin());
  EXPECT_FALSE(PointF(0.1f, 2).IsOrigin());
  EXPECT_FALSE(PointF(-0.1f, 0).IsOrigin());
  EXPECT_FALSE(PointF(0, -0.1f).IsOrigin());
  EXPECT_FALSE(PointF(-0.1f, -2).IsOrigin());
  EXPECT_TRUE(PointF(0, 0).IsOrigin());
}

TEST() [5/67]

gfx::TEST	(	PointTest	,
		Offset
	)

Definition at line 160 of file point_unittest.cc.

                        {
  Point test(3, 4);
  test.Offset(5, -8);
  EXPECT_EQ(test, Point(8, -4));
}

TEST() [6/67]

gfx::TEST	(	PointTest	,
		OffsetFromPoint
	)

Definition at line 61 of file point_unittest.cc.

                                 {
  Point a(1, 5);
  Point b(-20, 8);
  EXPECT_EQ(Vector2d(-20 - 1, 8 - 5).ToString(), (b - a).ToString());
}

TEST() [7/67]

gfx::TEST	(	PointTest	,
		Scale
	)

Definition at line 87 of file point_unittest.cc.

                       {
  EXPECT_EQ(PointF().ToString(), ScalePoint(PointF(), 2).ToString());
  EXPECT_EQ(PointF().ToString(), ScalePoint(PointF(), 2, 2).ToString());
 
  EXPECT_EQ(PointF(2, -2).ToString(), ScalePoint(PointF(1, -1), 2).ToString());
  EXPECT_EQ(PointF(2, -2).ToString(),
            ScalePoint(PointF(1, -1), 2, 2).ToString());
 
  PointF zero;
  PointF one(1, -1);
 
  zero.Scale(2);
  zero.Scale(3, 1.5);
 
  one.Scale(2);
  one.Scale(3, 1.5);
 
  EXPECT_EQ(PointF().ToString(), zero.ToString());
  EXPECT_EQ(PointF(6, -3).ToString(), one.ToString());
}

TEST() [8/67]

gfx::TEST	(	PointTest	,
		ToPointF
	)

Definition at line 14 of file point_unittest.cc.

                          {
  // Check that explicit conversion from integer to float compiles.
  Point a(10, 20);
  PointF b = PointF(a);
 
  EXPECT_EQ(static_cast<float>(a.x()), b.x());
  EXPECT_EQ(static_cast<float>(a.y()), b.y());
}

TEST() [9/67]

gfx::TEST	(	PointTest	,
		ToRoundedPoint
	)

Definition at line 67 of file point_unittest.cc.

                                {
  EXPECT_EQ(Point(0, 0), ToRoundedPoint(PointF(0, 0)));
  EXPECT_EQ(Point(0, 0), ToRoundedPoint(PointF(0.0001f, 0.0001f)));
  EXPECT_EQ(Point(0, 0), ToRoundedPoint(PointF(0.4999f, 0.4999f)));
  EXPECT_EQ(Point(1, 1), ToRoundedPoint(PointF(0.5f, 0.5f)));
  EXPECT_EQ(Point(1, 1), ToRoundedPoint(PointF(0.9999f, 0.9999f)));
 
  EXPECT_EQ(Point(10, 10), ToRoundedPoint(PointF(10, 10)));
  EXPECT_EQ(Point(10, 10), ToRoundedPoint(PointF(10.0001f, 10.0001f)));
  EXPECT_EQ(Point(10, 10), ToRoundedPoint(PointF(10.4999f, 10.4999f)));
  EXPECT_EQ(Point(11, 11), ToRoundedPoint(PointF(10.5f, 10.5f)));
  EXPECT_EQ(Point(11, 11), ToRoundedPoint(PointF(10.9999f, 10.9999f)));
 
  EXPECT_EQ(Point(-10, -10), ToRoundedPoint(PointF(-10, -10)));
  EXPECT_EQ(Point(-10, -10), ToRoundedPoint(PointF(-10.0001f, -10.0001f)));
  EXPECT_EQ(Point(-10, -10), ToRoundedPoint(PointF(-10.4999f, -10.4999f)));
  EXPECT_EQ(Point(-11, -11), ToRoundedPoint(PointF(-10.5f, -10.5f)));
  EXPECT_EQ(Point(-11, -11), ToRoundedPoint(PointF(-10.9999f, -10.9999f)));
}

TEST() [10/67]

gfx::TEST	(	PointTest	,
		VectorArithmetic
	)

Definition at line 41 of file point_unittest.cc.

                                  {
  Point a(1, 5);
  Vector2d v1(3, -3);
  Vector2d v2(-8, 1);
 
  static const struct {
    Point expected;
    Point actual;
  } tests[] = {{Point(4, 2), a + v1},
               {Point(-2, 8), a - v1},
               {a, a - v1 + v1},
               {a, a + v1 - v1},
               {a, a + Vector2d()},
               {Point(12, 1), a + v1 - v2},
               {Point(-10, 9), a - v1 + v2}};
 
  for (size_t i = 0; i < 7; ++i)
    EXPECT_EQ(tests[i].expected.ToString(), tests[i].actual.ToString());
}

TEST() [11/67]

gfx::TEST	(	PointTest	,
		VectorMath
	)

Definition at line 166 of file point_unittest.cc.

                            {
  Point test = Point(3, 4);
  test += Vector2d(5, -8);
  EXPECT_EQ(test, Point(8, -4));
 
  Point test2 = Point(3, 4);
  test2 -= Vector2d(5, -8);
  EXPECT_EQ(test2, Point(-2, 12));
}

TEST() [12/67]

gfx::TEST	(	RectTest	,
		AdjustToFit
	)

Definition at line 164 of file rect_unittest.cc.

                            {
  static const struct Test {
    int x1;  // source
    int y1;
    int w1;
    int h1;
    int x2;  // target
    int y2;
    int w2;
    int h2;
    int x3;  // rect 3: results of invoking AdjustToFit
    int y3;
    int w3;
    int h3;
  } tests[] = {{0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2},
               {2, 2, 3, 3, 0, 0, 4, 4, 1, 1, 3, 3},
               {-1, -1, 5, 5, 0, 0, 4, 4, 0, 0, 4, 4},
               {2, 2, 4, 4, 0, 0, 3, 3, 0, 0, 3, 3},
               {2, 2, 1, 1, 0, 0, 3, 3, 2, 2, 1, 1}};
  for (size_t i = 0; i < size(tests); ++i) {
    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
    Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
    Rect u = r1;
    u.AdjustToFit(r2);
    EXPECT_EQ(r3.x(), u.x());
    EXPECT_EQ(r3.y(), u.y());
    EXPECT_EQ(r3.width(), u.width());
    EXPECT_EQ(r3.height(), u.height());
  }
}

TEST() [13/67]

gfx::TEST	(	RectTest	,
		BoundingRect
	)

Definition at line 760 of file rect_unittest.cc.

                             {
  struct {
    Point a;
    Point b;
    Rect expected;
  } int_tests[] = {
      // If point B dominates A, then A should be the origin.
      {Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0)},
      {Point(4, 6), Point(8, 6), Rect(4, 6, 4, 0)},
      {Point(4, 6), Point(4, 9), Rect(4, 6, 0, 3)},
      {Point(4, 6), Point(8, 9), Rect(4, 6, 4, 3)},
      // If point A dominates B, then B should be the origin.
      {Point(4, 6), Point(4, 6), Rect(4, 6, 0, 0)},
      {Point(8, 6), Point(4, 6), Rect(4, 6, 4, 0)},
      {Point(4, 9), Point(4, 6), Rect(4, 6, 0, 3)},
      {Point(8, 9), Point(4, 6), Rect(4, 6, 4, 3)},
      // If neither point dominates, then the origin is a combination of the
      // two.
      {Point(4, 6), Point(6, 4), Rect(4, 4, 2, 2)},
      {Point(-4, -6), Point(-6, -4), Rect(-6, -6, 2, 2)},
      {Point(-4, 6), Point(6, -4), Rect(-4, -4, 10, 10)},
  };
 
  for (size_t i = 0; i < size(int_tests); ++i) {
    Rect actual = BoundingRect(int_tests[i].a, int_tests[i].b);
    EXPECT_EQ(int_tests[i].expected, actual);
  }
 
  struct {
    PointF a;
    PointF b;
    RectF expected;
  } float_tests[] = {
      // If point B dominates A, then A should be the origin.
      {PointF(4.2f, 6.8f), PointF(4.2f, 6.8f), RectF(4.2f, 6.8f, 0, 0)},
      {PointF(4.2f, 6.8f), PointF(8.5f, 6.8f), RectF(4.2f, 6.8f, 4.3f, 0)},
      {PointF(4.2f, 6.8f), PointF(4.2f, 9.3f), RectF(4.2f, 6.8f, 0, 2.5f)},
      {PointF(4.2f, 6.8f), PointF(8.5f, 9.3f), RectF(4.2f, 6.8f, 4.3f, 2.5f)},
      // If point A dominates B, then B should be the origin.
      {PointF(4.2f, 6.8f), PointF(4.2f, 6.8f), RectF(4.2f, 6.8f, 0, 0)},
      {PointF(8.5f, 6.8f), PointF(4.2f, 6.8f), RectF(4.2f, 6.8f, 4.3f, 0)},
      {PointF(4.2f, 9.3f), PointF(4.2f, 6.8f), RectF(4.2f, 6.8f, 0, 2.5f)},
      {PointF(8.5f, 9.3f), PointF(4.2f, 6.8f), RectF(4.2f, 6.8f, 4.3f, 2.5f)},
      // If neither point dominates, then the origin is a combination of the
      // two.
      {PointF(4.2f, 6.8f), PointF(6.8f, 4.2f), RectF(4.2f, 4.2f, 2.6f, 2.6f)},
      {PointF(-4.2f, -6.8f), PointF(-6.8f, -4.2f),
       RectF(-6.8f, -6.8f, 2.6f, 2.6f)},
      {PointF(-4.2f, 6.8f), PointF(6.8f, -4.2f),
       RectF(-4.2f, -4.2f, 11.0f, 11.0f)}};
 
  for (size_t i = 0; i < size(float_tests); ++i) {
    RectF actual = BoundingRect(float_tests[i].a, float_tests[i].b);
    EXPECT_RECTF_EQ(float_tests[i].expected, actual);
  }
}

TEST() [14/67]

gfx::TEST	(	RectTest	,
		CenterPoint
	)

Definition at line 297 of file rect_unittest.cc.

                            {
  Point center;
 
  // When origin is (0, 0).
  center = Rect(0, 0, 20, 20).CenterPoint();
  EXPECT_TRUE(center == Point(10, 10));
 
  // When origin is even.
  center = Rect(10, 10, 20, 20).CenterPoint();
  EXPECT_TRUE(center == Point(20, 20));
 
  // When origin is odd.
  center = Rect(11, 11, 20, 20).CenterPoint();
  EXPECT_TRUE(center == Point(21, 21));
 
  // When 0 width or height.
  center = Rect(10, 10, 0, 20).CenterPoint();
  EXPECT_TRUE(center == Point(10, 20));
  center = Rect(10, 10, 20, 0).CenterPoint();
  EXPECT_TRUE(center == Point(20, 10));
 
  // When an odd size.
  center = Rect(10, 10, 21, 21).CenterPoint();
  EXPECT_TRUE(center == Point(20, 20));
 
  // When an odd size and position.
  center = Rect(11, 11, 21, 21).CenterPoint();
  EXPECT_TRUE(center == Point(21, 21));
}

TEST() [15/67]

gfx::TEST	(	RectTest	,
		CenterPointF
	)

Definition at line 327 of file rect_unittest.cc.

                             {
  PointF center;
 
  // When origin is (0, 0).
  center = RectF(0, 0, 20, 20).CenterPoint();
  EXPECT_TRUE(center == PointF(10, 10));
 
  // When origin is even.
  center = RectF(10, 10, 20, 20).CenterPoint();
  EXPECT_TRUE(center == PointF(20, 20));
 
  // When origin is odd.
  center = RectF(11, 11, 20, 20).CenterPoint();
  EXPECT_TRUE(center == PointF(21, 21));
 
  // When 0 width or height.
  center = RectF(10, 10, 0, 20).CenterPoint();
  EXPECT_TRUE(center == PointF(10, 20));
  center = RectF(10, 10, 20, 0).CenterPoint();
  EXPECT_TRUE(center == PointF(20, 10));
 
  // When an odd size.
  center = RectF(10, 10, 21, 21).CenterPoint();
  EXPECT_TRUE(center == PointF(20.5f, 20.5f));
 
  // When an odd size and position.
  center = RectF(11, 11, 21, 21).CenterPoint();
  EXPECT_TRUE(center == PointF(21.5f, 21.5f));
}

TEST() [16/67]

gfx::TEST	(	RectTest	,
		Centers
	)

Definition at line 883 of file rect_unittest.cc.

                        {
  Rect i(10, 20, 30, 40);
  EXPECT_EQ(Point(10, 40), i.left_center());
  EXPECT_EQ(Point(25, 20), i.top_center());
  EXPECT_EQ(Point(40, 40), i.right_center());
  EXPECT_EQ(Point(25, 60), i.bottom_center());
 
  RectF f(10.1f, 20.2f, 30.3f, 40.4f);
  EXPECT_EQ(PointF(10.1f, 40.4f), f.left_center());
  EXPECT_EQ(PointF(25.25f, 20.2f), f.top_center());
  EXPECT_EQ(PointF(40.4f, 40.4f), f.right_center());
  EXPECT_EQ(25.25f, f.bottom_center().x());
  EXPECT_NEAR(60.6f, f.bottom_center().y(), 0.001f);
}

TEST() [17/67]

gfx::TEST	(	RectTest	,
		Contains
	)

Definition at line 25 of file rect_unittest.cc.

                         {
  static const struct ContainsCase {
    int rect_x;
    int rect_y;
    int rect_width;
    int rect_height;
    int point_x;
    int point_y;
    bool contained;
  } contains_cases[] = {
    {0, 0, 10, 10, 0, 0, true},
    {0, 0, 10, 10, 5, 5, true},
    {0, 0, 10, 10, 9, 9, true},
    {0, 0, 10, 10, 5, 10, false},
    {0, 0, 10, 10, 10, 5, false},
    {0, 0, 10, 10, -1, -1, false},
    {0, 0, 10, 10, 50, 50, false},
#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
    {0, 0, -10, -10, 0, 0, false},
#endif
  };
  for (size_t i = 0; i < size(contains_cases); ++i) {
    const ContainsCase& value = contains_cases[i];
    Rect rect(value.rect_x, value.rect_y, value.rect_width, value.rect_height);
    EXPECT_EQ(value.contained, rect.Contains(value.point_x, value.point_y));
  }
}

TEST() [18/67]

gfx::TEST	(	RectTest	,
		Corners
	)

Definition at line 868 of file rect_unittest.cc.

                        {
  Rect i(1, 2, 3, 4);
  RectF f(1.1f, 2.1f, 3.1f, 4.1f);
 
  EXPECT_EQ(Point(1, 2), i.origin());
  EXPECT_EQ(Point(4, 2), i.top_right());
  EXPECT_EQ(Point(1, 6), i.bottom_left());
  EXPECT_EQ(Point(4, 6), i.bottom_right());
 
  EXPECT_EQ(PointF(1.1f, 2.1f), f.origin());
  EXPECT_EQ(PointF(4.2f, 2.1f), f.top_right());
  EXPECT_EQ(PointF(1.1f, 6.2f), f.bottom_left());
  EXPECT_EQ(PointF(4.2f, 6.2f), f.bottom_right());
}

TEST() [19/67]

gfx::TEST	(	RectTest	,
		Equals
	)

Definition at line 155 of file rect_unittest.cc.

                       {
  ASSERT_TRUE(Rect(0, 0, 0, 0) == Rect(0, 0, 0, 0));
  ASSERT_TRUE(Rect(1, 2, 3, 4) == Rect(1, 2, 3, 4));
  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 0, 0, 1));
  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 0, 1, 0));
  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(0, 1, 0, 0));
  ASSERT_FALSE(Rect(0, 0, 0, 0) == Rect(1, 0, 0, 0));
}

TEST() [20/67]

gfx::TEST	(	RectTest	,
		IntegerOverflow
	)

Definition at line 971 of file rect_unittest.cc.

                                {
  int limit = std::numeric_limits<int>::max();
  int min_limit = std::numeric_limits<int>::min();
  int expected = 10;
  int large_number = limit - expected;
 
  Rect height_overflow(0, large_number, 100, 100);
  EXPECT_EQ(large_number, height_overflow.y());
  EXPECT_EQ(expected, height_overflow.height());
 
  Rect width_overflow(large_number, 0, 100, 100);
  EXPECT_EQ(large_number, width_overflow.x());
  EXPECT_EQ(expected, width_overflow.width());
 
  Rect size_height_overflow(Point(0, large_number), Size(100, 100));
  EXPECT_EQ(large_number, size_height_overflow.y());
  EXPECT_EQ(expected, size_height_overflow.height());
 
  Rect size_width_overflow(Point(large_number, 0), Size(100, 100));
  EXPECT_EQ(large_number, size_width_overflow.x());
  EXPECT_EQ(expected, size_width_overflow.width());
 
  Rect set_height_overflow(0, large_number, 100, 5);
  EXPECT_EQ(5, set_height_overflow.height());
  set_height_overflow.set_height(100);
  EXPECT_EQ(expected, set_height_overflow.height());
 
  Rect set_y_overflow(100, 100, 100, 100);
  EXPECT_EQ(100, set_y_overflow.height());
  set_y_overflow.set_y(large_number);
  EXPECT_EQ(expected, set_y_overflow.height());
 
  Rect set_width_overflow(large_number, 0, 5, 100);
  EXPECT_EQ(5, set_width_overflow.width());
  set_width_overflow.set_width(100);
  EXPECT_EQ(expected, set_width_overflow.width());
 
  Rect set_x_overflow(100, 100, 100, 100);
  EXPECT_EQ(100, set_x_overflow.width());
  set_x_overflow.set_x(large_number);
  EXPECT_EQ(expected, set_x_overflow.width());
 
  Point large_offset(large_number, large_number);
  Size size(100, 100);
  Size expected_size(10, 10);
 
  Rect set_origin_overflow(100, 100, 100, 100);
  EXPECT_EQ(size, set_origin_overflow.size());
  set_origin_overflow.set_origin(large_offset);
  EXPECT_EQ(large_offset, set_origin_overflow.origin());
  EXPECT_EQ(expected_size, set_origin_overflow.size());
 
  Rect set_size_overflow(large_number, large_number, 5, 5);
  EXPECT_EQ(Size(5, 5), set_size_overflow.size());
  set_size_overflow.set_size(size);
  EXPECT_EQ(large_offset, set_size_overflow.origin());
  EXPECT_EQ(expected_size, set_size_overflow.size());
 
  Rect set_rect_overflow;
  set_rect_overflow.SetRect(large_number, large_number, 100, 100);
  EXPECT_EQ(large_offset, set_rect_overflow.origin());
  EXPECT_EQ(expected_size, set_rect_overflow.size());
 
  // Insetting an empty rect, but the total inset (left + right) could overflow.
  Rect inset_overflow;
  inset_overflow.Inset(large_number, large_number, 100, 100);
  EXPECT_EQ(large_offset, inset_overflow.origin());
  EXPECT_EQ(gfx::Size(), inset_overflow.size());
 
  // Insetting where the total inset (width - left - right) could overflow.
  // Also, this insetting by the min limit in all directions cannot
  // represent width() without overflow, so that will also clamp.
  Rect inset_overflow2;
  inset_overflow2.Inset(min_limit, min_limit, min_limit, min_limit);
  EXPECT_EQ(inset_overflow2, gfx::Rect(min_limit, min_limit, limit, limit));
 
  // Insetting where the width shouldn't change, but if the insets operations
  // clamped in the wrong order, e.g. ((width - left) - right) vs (width - (left
  // + right)) then this will not work properly.  This is the proper order,
  // as if left + right overflows, the width cannot be decreased by more than
  // max int anyway.  Additionally, if left + right underflows, it cannot be
  // increased by more then max int.
  Rect inset_overflow3(0, 0, limit, limit);
  inset_overflow3.Inset(-100, -100, 100, 100);
  EXPECT_EQ(inset_overflow3, gfx::Rect(-100, -100, limit, limit));
 
  Rect inset_overflow4(-1000, -1000, limit, limit);
  inset_overflow4.Inset(100, 100, -100, -100);
  EXPECT_EQ(inset_overflow4, gfx::Rect(-900, -900, limit, limit));
 
  Rect offset_overflow(0, 0, 100, 100);
  offset_overflow.Offset(large_number, large_number);
  EXPECT_EQ(large_offset, offset_overflow.origin());
  EXPECT_EQ(expected_size, offset_overflow.size());
 
  Rect operator_overflow(0, 0, 100, 100);
  operator_overflow += Vector2d(large_number, large_number);
  EXPECT_EQ(large_offset, operator_overflow.origin());
  EXPECT_EQ(expected_size, operator_overflow.size());
 
  Rect origin_maxint(limit, limit, limit, limit);
  EXPECT_EQ(origin_maxint, Rect(gfx::Point(limit, limit), gfx::Size()));
 
  // Expect a rect at the origin and a rect whose right/bottom is maxint
  // create a rect that extends from 0..maxint in both extents.
  {
    Rect origin_small(0, 0, 100, 100);
    Rect big_clamped(50, 50, limit, limit);
    EXPECT_EQ(big_clamped.right(), limit);
 
    Rect unioned = UnionRects(origin_small, big_clamped);
    Rect rect_limit(0, 0, limit, limit);
    EXPECT_EQ(unioned, rect_limit);
  }
 
  // Expect a rect that would overflow width (but not right) to be clamped
  // and to have maxint extents after unioning.
  {
    Rect small(-500, -400, 100, 100);
    Rect big(-400, -500, limit, limit);
    // Technically, this should be limit + 100 width, but will clamp to maxint.
    EXPECT_EQ(UnionRects(small, big), Rect(-500, -500, limit, limit));
  }
 
  // Expect a rect that would overflow right *and* width to be clamped.
  {
    Rect clamped(500, 500, limit, limit);
    Rect positive_origin(100, 100, 500, 500);
 
    // Ideally, this should be (100, 100, limit + 400, limit + 400).
    // However, width overflows and would be clamped to limit, but right
    // overflows too and so will be clamped to limit - 100.
    Rect expected(100, 100, limit - 100, limit - 100);
    EXPECT_EQ(UnionRects(clamped, positive_origin), expected);
  }
 
  // Unioning a left=minint rect with a right=maxint rect.
  // We can't represent both ends of the spectrum in the same rect.
  // Make sure we keep the most useful area.
  {
    int part_limit = min_limit / 3;
    Rect left_minint(min_limit, min_limit, 1, 1);
    Rect right_maxint(limit - 1, limit - 1, limit, limit);
    Rect expected(part_limit, part_limit, 2 * part_limit, 2 * part_limit);
    Rect result = UnionRects(left_minint, right_maxint);
 
    // The result should be maximally big.
    EXPECT_EQ(limit, result.height());
    EXPECT_EQ(limit, result.width());
 
    // The result should include the area near the origin.
    EXPECT_GT(-part_limit, result.x());
    EXPECT_LT(part_limit, result.right());
    EXPECT_GT(-part_limit, result.y());
    EXPECT_LT(part_limit, result.bottom());
 
    // More succinctly, but harder to read in the results.
    EXPECT_TRUE(UnionRects(left_minint, right_maxint).Contains(expected));
  }
}

TEST() [21/67]

gfx::TEST	(	RectTest	,
		Intersect
	)

Definition at line 82 of file rect_unittest.cc.

                          {
  static const struct {
    int x1;  // rect 1
    int y1;
    int w1;
    int h1;
    int x2;  // rect 2
    int y2;
    int w2;
    int h2;
    int x3;  // rect 3: the union of rects 1 and 2
    int y3;
    int w3;
    int h3;
  } tests[] = {{0, 0, 0, 0,  // zeros
                0, 0, 0, 0, 0, 0, 0, 0},
               {0, 0, 4, 4,  // equal
                0, 0, 4, 4, 0, 0, 4, 4},
               {0, 0, 4, 4,  // neighboring
                4, 4, 4, 4, 0, 0, 0, 0},
               {0, 0, 4, 4,  // overlapping corners
                2, 2, 4, 4, 2, 2, 2, 2},
               {0, 0, 4, 4,  // T junction
                3, 1, 4, 2, 3, 1, 1, 2},
               {3, 0, 2, 2,  // gap
                0, 0, 2, 2, 0, 0, 0, 0}};
  for (size_t i = 0; i < size(tests); ++i) {
    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
    Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
    Rect ir = IntersectRects(r1, r2);
    EXPECT_EQ(r3.x(), ir.x());
    EXPECT_EQ(r3.y(), ir.y());
    EXPECT_EQ(r3.width(), ir.width());
    EXPECT_EQ(r3.height(), ir.height());
  }
}

TEST() [22/67]

gfx::TEST	(	RectTest	,
		Intersects
	)

Definition at line 53 of file rect_unittest.cc.

                           {
  static const struct {
    int x1;  // rect 1
    int y1;
    int w1;
    int h1;
    int x2;  // rect 2
    int y2;
    int w2;
    int h2;
    bool intersects;
  } tests[] = {{0, 0, 0, 0, 0, 0, 0, 0, false},
               {0, 0, 0, 0, -10, -10, 20, 20, false},
               {-10, 0, 0, 20, 0, -10, 20, 0, false},
               {0, 0, 10, 10, 0, 0, 10, 10, true},
               {0, 0, 10, 10, 10, 10, 10, 10, false},
               {10, 10, 10, 10, 0, 0, 10, 10, false},
               {10, 10, 10, 10, 5, 5, 10, 10, true},
               {10, 10, 10, 10, 15, 15, 10, 10, true},
               {10, 10, 10, 10, 20, 15, 10, 10, false},
               {10, 10, 10, 10, 21, 15, 10, 10, false}};
  for (size_t i = 0; i < size(tests); ++i) {
    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
    EXPECT_EQ(tests[i].intersects, r1.Intersects(r2));
    EXPECT_EQ(tests[i].intersects, r2.Intersects(r1));
  }
}

TEST() [23/67]

gfx::TEST	(	RectTest	,
		IsEmpty
	)

Definition at line 262 of file rect_unittest.cc.

                        {
  EXPECT_TRUE(Rect(0, 0, 0, 0).IsEmpty());
  EXPECT_TRUE(Rect(0, 0, 0, 0).size().IsEmpty());
  EXPECT_TRUE(Rect(0, 0, 10, 0).IsEmpty());
  EXPECT_TRUE(Rect(0, 0, 10, 0).size().IsEmpty());
  EXPECT_TRUE(Rect(0, 0, 0, 10).IsEmpty());
  EXPECT_TRUE(Rect(0, 0, 0, 10).size().IsEmpty());
  EXPECT_FALSE(Rect(0, 0, 10, 10).IsEmpty());
  EXPECT_FALSE(Rect(0, 0, 10, 10).size().IsEmpty());
}

TEST() [24/67]

gfx::TEST	(	RectTest	,
		IsExpressibleAsRect
	)

Definition at line 817 of file rect_unittest.cc.

                                    {
  EXPECT_TRUE(RectF().IsExpressibleAsRect());
 
  float min = static_cast<float>(std::numeric_limits<int>::min());
  float max = static_cast<float>(std::numeric_limits<int>::max());
  float infinity = std::numeric_limits<float>::infinity();
 
  EXPECT_TRUE(
      RectF(min + 200, min + 200, max - 200, max - 200).IsExpressibleAsRect());
  EXPECT_FALSE(
      RectF(min - 200, min + 200, max + 200, max + 200).IsExpressibleAsRect());
  EXPECT_FALSE(
      RectF(min + 200, min - 200, max + 200, max + 200).IsExpressibleAsRect());
  EXPECT_FALSE(
      RectF(min + 200, min + 200, max + 200, max - 200).IsExpressibleAsRect());
  EXPECT_FALSE(
      RectF(min + 200, min + 200, max - 200, max + 200).IsExpressibleAsRect());
 
  EXPECT_TRUE(RectF(0, 0, max - 200, max - 200).IsExpressibleAsRect());
  EXPECT_FALSE(RectF(200, 0, max + 200, max - 200).IsExpressibleAsRect());
  EXPECT_FALSE(RectF(0, 200, max - 200, max + 200).IsExpressibleAsRect());
  EXPECT_FALSE(RectF(0, 0, max + 200, max - 200).IsExpressibleAsRect());
  EXPECT_FALSE(RectF(0, 0, max - 200, max + 200).IsExpressibleAsRect());
 
  EXPECT_FALSE(RectF(infinity, 0, 1, 1).IsExpressibleAsRect());
  EXPECT_FALSE(RectF(0, infinity, 1, 1).IsExpressibleAsRect());
  EXPECT_FALSE(RectF(0, 0, infinity, 1).IsExpressibleAsRect());
  EXPECT_FALSE(RectF(0, 0, 1, infinity).IsExpressibleAsRect());
}

TEST() [25/67]

gfx::TEST	(	RectTest	,
		ManhattanDistanceToPoint
	)

Definition at line 908 of file rect_unittest.cc.

                                         {
  Rect i(1, 2, 3, 4);
  EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(1, 2)));
  EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(4, 6)));
  EXPECT_EQ(0, i.ManhattanDistanceToPoint(Point(2, 4)));
  EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(0, 0)));
  EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(2, 0)));
  EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(5, 0)));
  EXPECT_EQ(1, i.ManhattanDistanceToPoint(Point(5, 4)));
  EXPECT_EQ(3, i.ManhattanDistanceToPoint(Point(5, 8)));
  EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(3, 8)));
  EXPECT_EQ(2, i.ManhattanDistanceToPoint(Point(0, 7)));
  EXPECT_EQ(1, i.ManhattanDistanceToPoint(Point(0, 3)));
 
  RectF f(1.1f, 2.1f, 3.1f, 4.1f);
  EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(1.1f, 2.1f)));
  EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(4.2f, 6.f)));
  EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(2.f, 4.f)));
  EXPECT_FLOAT_EQ(3.2f, f.ManhattanDistanceToPoint(PointF(0.f, 0.f)));
  EXPECT_FLOAT_EQ(2.1f, f.ManhattanDistanceToPoint(PointF(2.f, 0.f)));
  EXPECT_FLOAT_EQ(2.9f, f.ManhattanDistanceToPoint(PointF(5.f, 0.f)));
  EXPECT_FLOAT_EQ(.8f, f.ManhattanDistanceToPoint(PointF(5.f, 4.f)));
  EXPECT_FLOAT_EQ(2.6f, f.ManhattanDistanceToPoint(PointF(5.f, 8.f)));
  EXPECT_FLOAT_EQ(1.8f, f.ManhattanDistanceToPoint(PointF(3.f, 8.f)));
  EXPECT_FLOAT_EQ(1.9f, f.ManhattanDistanceToPoint(PointF(0.f, 7.f)));
  EXPECT_FLOAT_EQ(1.1f, f.ManhattanDistanceToPoint(PointF(0.f, 3.f)));
}

TEST() [26/67]

gfx::TEST	(	RectTest	,
		ManhattanInternalDistance
	)

Definition at line 936 of file rect_unittest.cc.

                                          {
  Rect i(0, 0, 400, 400);
  EXPECT_EQ(0, i.ManhattanInternalDistance(gfx::Rect(-1, 0, 2, 1)));
  EXPECT_EQ(1, i.ManhattanInternalDistance(gfx::Rect(400, 0, 1, 400)));
  EXPECT_EQ(2, i.ManhattanInternalDistance(gfx::Rect(-100, -100, 100, 100)));
  EXPECT_EQ(2, i.ManhattanInternalDistance(gfx::Rect(-101, 100, 100, 100)));
  EXPECT_EQ(4, i.ManhattanInternalDistance(gfx::Rect(-101, -101, 100, 100)));
  EXPECT_EQ(435, i.ManhattanInternalDistance(gfx::Rect(630, 603, 100, 100)));
 
  RectF f(0.0f, 0.0f, 400.0f, 400.0f);
  static const float kEpsilon = std::numeric_limits<float>::epsilon();
 
  EXPECT_FLOAT_EQ(
      0.0f, f.ManhattanInternalDistance(gfx::RectF(-1.0f, 0.0f, 2.0f, 1.0f)));
  EXPECT_FLOAT_EQ(kEpsilon, f.ManhattanInternalDistance(
                                gfx::RectF(400.0f, 0.0f, 1.0f, 400.0f)));
  EXPECT_FLOAT_EQ(2.0f * kEpsilon, f.ManhattanInternalDistance(gfx::RectF(
                                       -100.0f, -100.0f, 100.0f, 100.0f)));
  EXPECT_FLOAT_EQ(1.0f + kEpsilon, f.ManhattanInternalDistance(gfx::RectF(
                                       -101.0f, 100.0f, 100.0f, 100.0f)));
  EXPECT_FLOAT_EQ(2.0f + 2.0f * kEpsilon,
                  f.ManhattanInternalDistance(
                      gfx::RectF(-101.0f, -101.0f, 100.0f, 100.0f)));
  EXPECT_FLOAT_EQ(
      433.0f + 2.0f * kEpsilon,
      f.ManhattanInternalDistance(gfx::RectF(630.0f, 603.0f, 100.0f, 100.0f)));
 
  EXPECT_FLOAT_EQ(
      0.0f, f.ManhattanInternalDistance(gfx::RectF(-1.0f, 0.0f, 1.1f, 1.0f)));
  EXPECT_FLOAT_EQ(0.1f + kEpsilon, f.ManhattanInternalDistance(
                                       gfx::RectF(-1.5f, 0.0f, 1.4f, 1.0f)));
  EXPECT_FLOAT_EQ(kEpsilon, f.ManhattanInternalDistance(
                                gfx::RectF(-1.5f, 0.0f, 1.5f, 1.0f)));
}

TEST() [27/67]

gfx::TEST	(	RectTest	,
		Offset
	)

Definition at line 847 of file rect_unittest.cc.

                       {
  Rect i(1, 2, 3, 4);
 
  EXPECT_EQ(Rect(2, 1, 3, 4), (i + Vector2d(1, -1)));
  EXPECT_EQ(Rect(2, 1, 3, 4), (Vector2d(1, -1) + i));
  i += Vector2d(1, -1);
  EXPECT_EQ(Rect(2, 1, 3, 4), i);
  EXPECT_EQ(Rect(1, 2, 3, 4), (i - Vector2d(1, -1)));
  i -= Vector2d(1, -1);
  EXPECT_EQ(Rect(1, 2, 3, 4), i);
 
  RectF f(1.1f, 2.2f, 3.3f, 4.4f);
  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (f + Vector2dF(1.1f, -1.1f)));
  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (Vector2dF(1.1f, -1.1f) + f));
  f += Vector2dF(1.1f, -1.1f);
  EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), f);
  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), (f - Vector2dF(1.1f, -1.1f)));
  f -= Vector2dF(1.1f, -1.1f);
  EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), f);
}

TEST() [28/67]

gfx::TEST	(	RectTest	,
		ScaleRect
	)

Definition at line 399 of file rect_unittest.cc.

                          {
  static const struct Test {
    int x1;  // source
    int y1;
    int w1;
    int h1;
    float scale;
    float x2;  // target
    float y2;
    float w2;
    float h2;
  } tests[] = {
      {3, 3, 3, 3, 1.5f, 4.5f, 4.5f, 4.5f, 4.5f},
      {3, 3, 3, 3, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f},
      {3, 3, 3, 3, std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::quiet_NaN(),
       std::numeric_limits<float>::quiet_NaN()},
      {3, 3, 3, 3, std::numeric_limits<float>::max(),
       std::numeric_limits<float>::max(), std::numeric_limits<float>::max(),
       std::numeric_limits<float>::max(), std::numeric_limits<float>::max()}};
 
  for (size_t i = 0; i < size(tests); ++i) {
    RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
    RectF r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 
    RectF scaled = ScaleRect(r1, tests[i].scale);
    EXPECT_FLOAT_AND_NAN_EQ(r2.x(), scaled.x());
    EXPECT_FLOAT_AND_NAN_EQ(r2.y(), scaled.y());
    EXPECT_FLOAT_AND_NAN_EQ(r2.width(), scaled.width());
    EXPECT_FLOAT_AND_NAN_EQ(r2.height(), scaled.height());
  }
}

TEST() [29/67]

gfx::TEST	(	RectTest	,
		ScaleToEnclosedRect
	)

Definition at line 643 of file rect_unittest.cc.

                                    {
  static const struct Test {
    Rect input_rect;
    float input_scale;
    Rect expected_rect;
  } tests[] = {{
                   Rect(),
                   5.f,
                   Rect(),
               },
               {
                   Rect(1, 1, 1, 1),
                   5.f,
                   Rect(5, 5, 5, 5),
               },
               {
                   Rect(-1, -1, 0, 0),
                   5.f,
                   Rect(-5, -5, 0, 0),
               },
               {
                   Rect(1, -1, 0, 1),
                   5.f,
                   Rect(5, -5, 0, 5),
               },
               {
                   Rect(-1, 1, 1, 0),
                   5.f,
                   Rect(-5, 5, 5, 0),
               },
               {
                   Rect(1, 2, 3, 4),
                   1.5f,
                   Rect(2, 3, 4, 6),
               },
               {
                   Rect(-1, -2, 0, 0),
                   1.5f,
                   Rect(-1, -3, 0, 0),
               }};
 
  for (size_t i = 0; i < size(tests); ++i) {
    Rect result =
        ScaleToEnclosedRect(tests[i].input_rect, tests[i].input_scale);
    EXPECT_EQ(tests[i].expected_rect, result);
  }
}

TEST() [30/67]

gfx::TEST	(	RectTest	,
		ScaleToEnclosingRect
	)

Definition at line 691 of file rect_unittest.cc.

                                     {
  static const struct Test {
    Rect input_rect;
    float input_scale;
    Rect expected_rect;
  } tests[] = {{
                   Rect(),
                   5.f,
                   Rect(),
               },
               {
                   Rect(1, 1, 1, 1),
                   5.f,
                   Rect(5, 5, 5, 5),
               },
               {
                   Rect(-1, -1, 0, 0),
                   5.f,
                   Rect(-5, -5, 0, 0),
               },
               {
                   Rect(1, -1, 0, 1),
                   5.f,
                   Rect(5, -5, 0, 5),
               },
               {
                   Rect(-1, 1, 1, 0),
                   5.f,
                   Rect(-5, 5, 5, 0),
               },
               {
                   Rect(1, 2, 3, 4),
                   1.5f,
                   Rect(1, 3, 5, 6),
               },
               {
                   Rect(-1, -2, 0, 0),
                   1.5f,
                   Rect(-2, -3, 0, 0),
               }};
 
  for (size_t i = 0; i < size(tests); ++i) {
    Rect result =
        ScaleToEnclosingRect(tests[i].input_rect, tests[i].input_scale);
    EXPECT_EQ(tests[i].expected_rect, result);
    Rect result_safe =
        ScaleToEnclosingRectSafe(tests[i].input_rect, tests[i].input_scale);
    EXPECT_EQ(tests[i].expected_rect, result_safe);
  }
}

TEST() [31/67]

gfx::TEST	(	RectTest	,
		ScaleToEnclosingRectSafe
	)

Definition at line 1132 of file rect_unittest.cc.

                                         {
  const int max_int = std::numeric_limits<int>::max();
  const int min_int = std::numeric_limits<int>::min();
  const float max_float = std::numeric_limits<float>::max();
 
  Rect xy_underflow(-100000, -123456, 10, 20);
  EXPECT_EQ(ScaleToEnclosingRectSafe(xy_underflow, 100000, 100000),
            Rect(min_int, min_int, 1000000, 2000000));
 
  // A location overflow means that width/right and bottom/top also
  // overflow so need to be clamped.
  Rect xy_overflow(100000, 123456, 10, 20);
  EXPECT_EQ(ScaleToEnclosingRectSafe(xy_overflow, 100000, 100000),
            Rect(max_int, max_int, 0, 0));
 
  // In practice all rects are clamped to 0 width / 0 height so
  // negative sizes don't matter, but try this for the sake of testing.
  Rect size_underflow(-1, -2, 100000, 100000);
  EXPECT_EQ(ScaleToEnclosingRectSafe(size_underflow, -100000, -100000),
            Rect(100000, 200000, 0, 0));
 
  Rect size_overflow(-1, -2, 123456, 234567);
  EXPECT_EQ(ScaleToEnclosingRectSafe(size_overflow, 100000, 100000),
            Rect(-100000, -200000, max_int, max_int));
  // Verify width/right gets clamped properly too if x/y positive.
  Rect size_overflow2(1, 2, 123456, 234567);
  EXPECT_EQ(ScaleToEnclosingRectSafe(size_overflow2, 100000, 100000),
            Rect(100000, 200000, max_int - 100000, max_int - 200000));
 
  Rect max_rect(max_int, max_int, max_int, max_int);
  EXPECT_EQ(ScaleToEnclosingRectSafe(max_rect, max_float, max_float),
            Rect(max_int, max_int, 0, 0));
 
  Rect min_rect(min_int, min_int, max_int, max_int);
  // Min rect can't be scaled up any further in any dimension.
  EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, 2, 3.5), min_rect);
  EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, max_float, max_float), min_rect);
  // Min rect scaled by min is an empty rect at (max, max)
  EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, min_int, min_int), max_rect);
}

TEST() [32/67]

gfx::TEST	(	RectTest	,
		SharesEdgeWith
	)

Definition at line 357 of file rect_unittest.cc.

                               {
  Rect r(2, 3, 4, 5);
 
  // Must be non-overlapping
  EXPECT_FALSE(r.SharesEdgeWith(r));
 
  Rect just_above(2, 1, 4, 2);
  Rect just_below(2, 8, 4, 2);
  Rect just_left(0, 3, 2, 5);
  Rect just_right(6, 3, 2, 5);
 
  EXPECT_TRUE(r.SharesEdgeWith(just_above));
  EXPECT_TRUE(r.SharesEdgeWith(just_below));
  EXPECT_TRUE(r.SharesEdgeWith(just_left));
  EXPECT_TRUE(r.SharesEdgeWith(just_right));
 
  // Wrong placement
  Rect same_height_no_edge(0, 0, 1, 5);
  Rect same_width_no_edge(0, 0, 4, 1);
 
  EXPECT_FALSE(r.SharesEdgeWith(same_height_no_edge));
  EXPECT_FALSE(r.SharesEdgeWith(same_width_no_edge));
 
  Rect just_above_no_edge(2, 1, 5, 2);  // too wide
  Rect just_below_no_edge(2, 8, 3, 2);  // too narrow
  Rect just_left_no_edge(0, 3, 2, 6);   // too tall
  Rect just_right_no_edge(6, 3, 2, 4);  // too short
 
  EXPECT_FALSE(r.SharesEdgeWith(just_above_no_edge));
  EXPECT_FALSE(r.SharesEdgeWith(just_below_no_edge));
  EXPECT_FALSE(r.SharesEdgeWith(just_left_no_edge));
  EXPECT_FALSE(r.SharesEdgeWith(just_right_no_edge));
}

TEST() [33/67]

gfx::TEST	(	RectTest	,
		SplitVertically
	)

Definition at line 273 of file rect_unittest.cc.

                                {
  Rect left_half, right_half;
 
  // Splitting when origin is (0, 0).
  Rect(0, 0, 20, 20).SplitVertically(&left_half, &right_half);
  EXPECT_TRUE(left_half == Rect(0, 0, 10, 20));
  EXPECT_TRUE(right_half == Rect(10, 0, 10, 20));
 
  // Splitting when origin is arbitrary.
  Rect(10, 10, 20, 10).SplitVertically(&left_half, &right_half);
  EXPECT_TRUE(left_half == Rect(10, 10, 10, 10));
  EXPECT_TRUE(right_half == Rect(20, 10, 10, 10));
 
  // Splitting a rectangle of zero width.
  Rect(10, 10, 0, 10).SplitVertically(&left_half, &right_half);
  EXPECT_TRUE(left_half == Rect(10, 10, 0, 10));
  EXPECT_TRUE(right_half == Rect(10, 10, 0, 10));
 
  // Splitting a rectangle of odd width.
  Rect(10, 10, 5, 10).SplitVertically(&left_half, &right_half);
  EXPECT_TRUE(left_half == Rect(10, 10, 2, 10));
  EXPECT_TRUE(right_half == Rect(12, 10, 3, 10));
}

TEST() [34/67]

gfx::TEST	(	RectTest	,
		Subtract
	)

Definition at line 196 of file rect_unittest.cc.

                         {
  Rect result;
 
  // Matching
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(10, 10, 20, 20));
  EXPECT_EQ(Rect(0, 0, 0, 0), result);
 
  // Contains
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(5, 5, 30, 30));
  EXPECT_EQ(Rect(0, 0, 0, 0), result);
 
  // No intersection
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(30, 30, 30, 30));
  EXPECT_EQ(Rect(10, 10, 20, 20), result);
 
  // Not a complete intersection in either direction
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(15, 15, 20, 20));
  EXPECT_EQ(Rect(10, 10, 20, 20), result);
 
  // Complete intersection in the x-direction, top edge is fully covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(10, 15, 20, 20));
  EXPECT_EQ(Rect(10, 10, 20, 5), result);
 
  // Complete intersection in the x-direction, top edge is fully covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(5, 15, 30, 20));
  EXPECT_EQ(Rect(10, 10, 20, 5), result);
 
  // Complete intersection in the x-direction, bottom edge is fully covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(5, 5, 30, 20));
  EXPECT_EQ(Rect(10, 25, 20, 5), result);
 
  // Complete intersection in the x-direction, none of the edges is fully
  // covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(5, 15, 30, 1));
  EXPECT_EQ(Rect(10, 10, 20, 20), result);
 
  // Complete intersection in the y-direction, left edge is fully covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(10, 10, 10, 30));
  EXPECT_EQ(Rect(20, 10, 10, 20), result);
 
  // Complete intersection in the y-direction, left edge is fully covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(5, 5, 20, 30));
  EXPECT_EQ(Rect(25, 10, 5, 20), result);
 
  // Complete intersection in the y-direction, right edge is fully covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(20, 5, 20, 30));
  EXPECT_EQ(Rect(10, 10, 10, 20), result);
 
  // Complete intersection in the y-direction, none of the edges is fully
  // covered.
  result = Rect(10, 10, 20, 20);
  result.Subtract(Rect(15, 5, 1, 30));
  EXPECT_EQ(Rect(10, 10, 20, 20), result);
}

TEST() [35/67]

gfx::TEST	(	RectTest	,
		ToEnclosedRect
	)

Definition at line 434 of file rect_unittest.cc.

                               {
  static const int max_int = std::numeric_limits<int>::max();
  static const int min_int = std::numeric_limits<int>::min();
  static const float max_float = std::numeric_limits<float>::max();
  static const float max_int_f = static_cast<float>(max_int);
  static const float min_int_f = static_cast<float>(min_int);
 
  static const struct Test {
    struct {
      float x;
      float y;
      float width;
      float height;
    } in;
    struct {
      int x;
      int y;
      int width;
      int height;
    } expected;
  } tests[] = {
      {{0.0f, 0.0f, 0.0f, 0.0f}, {0, 0, 0, 0}},
      {{-1.5f, -1.5f, 3.0f, 3.0f}, {-1, -1, 2, 2}},
      {{-1.5f, -1.5f, 3.5f, 3.5f}, {-1, -1, 3, 3}},
      {{max_float, max_float, 2.0f, 2.0f}, {max_int, max_int, 0, 0}},
      {{0.0f, 0.0f, max_float, max_float}, {0, 0, max_int, max_int}},
      {{20000.5f, 20000.5f, 0.5f, 0.5f}, {20001, 20001, 0, 0}},
      {{max_int_f, max_int_f, max_int_f, max_int_f}, {max_int, max_int, 0, 0}},
      {{1.9999f, 2.0002f, 5.9998f, 6.0001f}, {2, 3, 5, 5}},
      {{1.9999f, 2.0001f, 6.0002f, 5.9998f}, {2, 3, 6, 4}},
      {{1.9998f, 2.0002f, 6.0001f, 5.9999f}, {2, 3, 5, 5}}};
 
  for (size_t i = 0; i < size(tests); ++i) {
    RectF source(tests[i].in.x, tests[i].in.y, tests[i].in.width,
                 tests[i].in.height);
    Rect enclosed = ToEnclosedRect(source);
 
    EXPECT_EQ(tests[i].expected.x, enclosed.x());
    EXPECT_EQ(tests[i].expected.y, enclosed.y());
    EXPECT_EQ(tests[i].expected.width, enclosed.width());
    EXPECT_EQ(tests[i].expected.height, enclosed.height());
  }
 
  {
    RectF source(min_int_f, min_int_f, max_int_f * 3.f, max_int_f * 3.f);
    Rect enclosed = ToEnclosedRect(source);
 
    // That rect can't be represented, but it should be big.
    EXPECT_EQ(max_int, enclosed.width());
    EXPECT_EQ(max_int, enclosed.height());
    // It should include some axis near the global origin.
    EXPECT_GT(1, enclosed.x());
    EXPECT_GT(1, enclosed.y());
    // And it should not cause computation issues for itself.
    EXPECT_LT(0, enclosed.right());
    EXPECT_LT(0, enclosed.bottom());
  }
}

TEST() [36/67]

gfx::TEST	(	RectTest	,
		ToEnclosingRect
	)

Definition at line 493 of file rect_unittest.cc.

                                {
  static const int max_int = std::numeric_limits<int>::max();
  static const int min_int = std::numeric_limits<int>::min();
  static const float max_float = std::numeric_limits<float>::max();
  static const float epsilon_float = std::numeric_limits<float>::epsilon();
  static const float max_int_f = static_cast<float>(max_int);
  static const float min_int_f = static_cast<float>(min_int);
  static const struct Test {
    struct {
      float x;
      float y;
      float width;
      float height;
    } in;
    struct {
      int x;
      int y;
      int width;
      int height;
    } expected;
  } tests[] = {
      {{0.0f, 0.0f, 0.0f, 0.0f}, {0, 0, 0, 0}},
      {{5.5f, 5.5f, 0.0f, 0.0f}, {5, 5, 0, 0}},
      {{3.5f, 2.5f, epsilon_float, -0.0f}, {3, 2, 0, 0}},
      {{3.5f, 2.5f, 0.f, 0.001f}, {3, 2, 0, 1}},
      {{-1.5f, -1.5f, 3.0f, 3.0f}, {-2, -2, 4, 4}},
      {{-1.5f, -1.5f, 3.5f, 3.5f}, {-2, -2, 4, 4}},
      {{max_float, max_float, 2.0f, 2.0f}, {max_int, max_int, 0, 0}},
      {{0.0f, 0.0f, max_float, max_float}, {0, 0, max_int, max_int}},
      {{20000.5f, 20000.5f, 0.5f, 0.5f}, {20000, 20000, 1, 1}},
      {{max_int_f, max_int_f, max_int_f, max_int_f}, {max_int, max_int, 0, 0}},
      {{-0.5f, -0.5f, 22777712.f, 1.f}, {-1, -1, 22777713, 2}},
      {{1.9999f, 2.0002f, 5.9998f, 6.0001f}, {1, 2, 7, 7}},
      {{1.9999f, 2.0001f, 6.0002f, 5.9998f}, {1, 2, 8, 6}},
      {{1.9998f, 2.0002f, 6.0001f, 5.9999f}, {1, 2, 7, 7}}};
 
  for (size_t i = 0; i < size(tests); ++i) {
    RectF source(tests[i].in.x, tests[i].in.y, tests[i].in.width,
                 tests[i].in.height);
 
    Rect enclosing = ToEnclosingRect(source);
    EXPECT_EQ(tests[i].expected.x, enclosing.x());
    EXPECT_EQ(tests[i].expected.y, enclosing.y());
    EXPECT_EQ(tests[i].expected.width, enclosing.width());
    EXPECT_EQ(tests[i].expected.height, enclosing.height());
  }
 
  {
    RectF source(min_int_f, min_int_f, max_int_f * 3.f, max_int_f * 3.f);
    Rect enclosing = ToEnclosingRect(source);
 
    // That rect can't be represented, but it should be big.
    EXPECT_EQ(max_int, enclosing.width());
    EXPECT_EQ(max_int, enclosing.height());
    // It should include some axis near the global origin.
    EXPECT_GT(1, enclosing.x());
    EXPECT_GT(1, enclosing.y());
    // And it should cause computation issues for itself.
    EXPECT_LT(0, enclosing.right());
    EXPECT_LT(0, enclosing.bottom());
  }
}

TEST() [37/67]

gfx::TEST	(	RectTest	,
		ToEnclosingRectIgnoringError
	)

Definition at line 556 of file rect_unittest.cc.

                                             {
  static const int max_int = std::numeric_limits<int>::max();
  static const float max_float = std::numeric_limits<float>::max();
  static const float epsilon_float = std::numeric_limits<float>::epsilon();
  static const float max_int_f = static_cast<float>(max_int);
  static const float error = 0.001f;
  static const struct Test {
    struct {
      float x;
      float y;
      float width;
      float height;
    } in;
    struct {
      int x;
      int y;
      int width;
      int height;
    } expected;
  } tests[] = {
      {{0.0f, 0.0f, 0.0f, 0.0f}, {0, 0, 0, 0}},
      {{5.5f, 5.5f, 0.0f, 0.0f}, {5, 5, 0, 0}},
      {{3.5f, 2.5f, epsilon_float, -0.0f}, {3, 2, 0, 0}},
      {{3.5f, 2.5f, 0.f, 0.001f}, {3, 2, 0, 1}},
      {{-1.5f, -1.5f, 3.0f, 3.0f}, {-2, -2, 4, 4}},
      {{-1.5f, -1.5f, 3.5f, 3.5f}, {-2, -2, 4, 4}},
      {{max_float, max_float, 2.0f, 2.0f}, {max_int, max_int, 0, 0}},
      {{0.0f, 0.0f, max_float, max_float}, {0, 0, max_int, max_int}},
      {{20000.5f, 20000.5f, 0.5f, 0.5f}, {20000, 20000, 1, 1}},
      {{max_int_f, max_int_f, max_int_f, max_int_f}, {max_int, max_int, 0, 0}},
      {{-0.5f, -0.5f, 22777712.f, 1.f}, {-1, -1, 22777713, 2}},
      {{1.9999f, 2.0002f, 5.9998f, 6.0001f}, {2, 2, 6, 6}},
      {{1.9999f, 2.0001f, 6.0002f, 5.9998f}, {2, 2, 6, 6}},
      {{1.9998f, 2.0002f, 6.0001f, 5.9999f}, {2, 2, 6, 6}}};
 
  for (size_t i = 0; i < size(tests); ++i) {
    RectF source(tests[i].in.x, tests[i].in.y, tests[i].in.width,
                 tests[i].in.height);
 
    Rect enclosing = ToEnclosingRectIgnoringError(source, error);
    EXPECT_EQ(tests[i].expected.x, enclosing.x());
    EXPECT_EQ(tests[i].expected.y, enclosing.y());
    EXPECT_EQ(tests[i].expected.width, enclosing.width());
    EXPECT_EQ(tests[i].expected.height, enclosing.height());
  }
}

TEST() [38/67]

gfx::TEST	(	RectTest	,
		ToFlooredRect
	)

Definition at line 614 of file rect_unittest.cc.

                              {
  static const struct Test {
    float x1;  // source
    float y1;
    float w1;
    float h1;
    int x2;  // target
    int y2;
    int w2;
    int h2;
  } tests[] = {
      {0.0f, 0.0f, 0.0f, 0.0f, 0, 0, 0, 0},
      {-1.5f, -1.5f, 3.0f, 3.0f, -2, -2, 3, 3},
      {-1.5f, -1.5f, 3.5f, 3.5f, -2, -2, 3, 3},
      {20000.5f, 20000.5f, 0.5f, 0.5f, 20000, 20000, 0, 0},
  };
 
  for (size_t i = 0; i < size(tests); ++i) {
    RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 
    Rect floored = ToFlooredRectDeprecated(r1);
    EXPECT_FLOAT_EQ(r2.x(), floored.x());
    EXPECT_FLOAT_EQ(r2.y(), floored.y());
    EXPECT_FLOAT_EQ(r2.width(), floored.width());
    EXPECT_FLOAT_EQ(r2.height(), floored.height());
  }
}

TEST() [39/67]

gfx::TEST	(	RectTest	,
		ToNearestRect
	)

Definition at line 603 of file rect_unittest.cc.

                              {
  Rect rect;
  EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
 
  rect = Rect(-1, -1, 3, 3);
  EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
 
  RectF rectf(-1.00001f, -0.999999f, 3.0000001f, 2.999999f);
  EXPECT_EQ(rect, ToNearestRect(rectf));
}

TEST() [40/67]

gfx::TEST	(	RectTest	,
		ToRectF
	)

Definition at line 751 of file rect_unittest.cc.

                        {
  // Check that explicit conversion from integer to float compiles.
  Rect a(10, 20, 30, 40);
  RectF b(10, 20, 30, 40);
 
  RectF c = RectF(a);
  EXPECT_EQ(b, c);
}

TEST() [41/67]

gfx::TEST	(	RectTest	,
		Transpose
	)

Definition at line 898 of file rect_unittest.cc.

                          {
  Rect i(10, 20, 30, 40);
  i.Transpose();
  EXPECT_EQ(Rect(20, 10, 40, 30), i);
 
  RectF f(10.1f, 20.2f, 30.3f, 40.4f);
  f.Transpose();
  EXPECT_EQ(RectF(20.2f, 10.1f, 40.4f, 30.3f), f);
}

TEST() [42/67]

gfx::TEST	(	RectTest	,
		Union
	)

Definition at line 120 of file rect_unittest.cc.

                      {
  static const struct Test {
    int x1;  // rect 1
    int y1;
    int w1;
    int h1;
    int x2;  // rect 2
    int y2;
    int w2;
    int h2;
    int x3;  // rect 3: the union of rects 1 and 2
    int y3;
    int w3;
    int h3;
  } tests[] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
               {0, 0, 4, 4, 0, 0, 4, 4, 0, 0, 4, 4},
               {0, 0, 4, 4, 4, 4, 4, 4, 0, 0, 8, 8},
               {0, 0, 4, 4, 0, 5, 4, 4, 0, 0, 4, 9},
               {0, 0, 2, 2, 3, 3, 2, 2, 0, 0, 5, 5},
               {3, 3, 2, 2,  // reverse r1 and r2 from previous test
                0, 0, 2, 2, 0, 0, 5, 5},
               {0, 0, 0, 0,  // union with empty rect
                2, 2, 2, 2, 2, 2, 2, 2}};
  for (size_t i = 0; i < size(tests); ++i) {
    Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
    Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
    Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
    Rect u = UnionRects(r1, r2);
    EXPECT_EQ(r3.x(), u.x());
    EXPECT_EQ(r3.y(), u.y());
    EXPECT_EQ(r3.width(), u.width());
    EXPECT_EQ(r3.height(), u.height());
  }
}

TEST() [43/67]

gfx::TEST	(	SizeTest	,
		ClampSize
	)

Definition at line 75 of file size_unittest.cc.

                          {
  Size a;
 
  a = Size(3, 5);
  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
  a.SetToMax(Size(2, 4));
  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
  a.SetToMax(Size(3, 5));
  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
  a.SetToMax(Size(4, 2));
  EXPECT_EQ(Size(4, 5).ToString(), a.ToString());
  a.SetToMax(Size(8, 10));
  EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
 
  a.SetToMin(Size(9, 11));
  EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
  a.SetToMin(Size(8, 10));
  EXPECT_EQ(Size(8, 10).ToString(), a.ToString());
  a.SetToMin(Size(11, 9));
  EXPECT_EQ(Size(8, 9).ToString(), a.ToString());
  a.SetToMin(Size(7, 11));
  EXPECT_EQ(Size(7, 9).ToString(), a.ToString());
  a.SetToMin(Size(3, 5));
  EXPECT_EQ(Size(3, 5).ToString(), a.ToString());
}

TEST() [44/67]

gfx::TEST	(	SizeTest	,
		ClampSizeF
	)

Definition at line 101 of file size_unittest.cc.

                           {
  SizeF a;
 
  a = SizeF(3.5f, 5.5f);
  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(SizeF(2.5f, 4.5f));
  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(SizeF(3.5f, 5.5f));
  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(SizeF(4.5f, 2.5f));
  EXPECT_EQ(SizeF(4.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(SizeF(8.5f, 10.5f));
  EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
 
  a.SetToMin(SizeF(9.5f, 11.5f));
  EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
  a.SetToMin(SizeF(8.5f, 10.5f));
  EXPECT_EQ(SizeF(8.5f, 10.5f).ToString(), a.ToString());
  a.SetToMin(SizeF(11.5f, 9.5f));
  EXPECT_EQ(SizeF(8.5f, 9.5f).ToString(), a.ToString());
  a.SetToMin(SizeF(7.5f, 11.5f));
  EXPECT_EQ(SizeF(7.5f, 9.5f).ToString(), a.ToString());
  a.SetToMin(SizeF(3.5f, 5.5f));
  EXPECT_EQ(SizeF(3.5f, 5.5f).ToString(), a.ToString());
}

TEST() [45/67]

gfx::TEST	(	SizeTest	,
		ClampsToZero
	)

Definition at line 203 of file size_unittest.cc.

                             {
  const float clearly_trivial = kTrivial / 2.f;
  const float nearly_trivial = kTrivial * 1.5f;
 
  SizeF test(clearly_trivial, 1.f);
 
  EXPECT_FLOAT_EQ(0.f, test.width());
  EXPECT_FLOAT_EQ(1.f, test.height());
 
  test.SetSize(.01f, clearly_trivial);
 
  EXPECT_FLOAT_EQ(.01f, test.width());
  EXPECT_FLOAT_EQ(0.f, test.height());
 
  test.SetSize(nearly_trivial, nearly_trivial);
 
  EXPECT_FLOAT_EQ(nearly_trivial, test.width());
  EXPECT_FLOAT_EQ(nearly_trivial, test.height());
 
  test.Scale(0.5f);
 
  EXPECT_FLOAT_EQ(0.f, test.width());
  EXPECT_FLOAT_EQ(0.f, test.height());
 
  test.SetSize(0.f, 0.f);
  test.Enlarge(clearly_trivial, clearly_trivial);
  test.Enlarge(clearly_trivial, clearly_trivial);
  test.Enlarge(clearly_trivial, clearly_trivial);
 
  EXPECT_EQ(SizeF(0.f, 0.f), test);
}

TEST() [46/67]

gfx::TEST	(	SizeTest	,
		ConsistentClamping
	)

Definition at line 237 of file size_unittest.cc.

                                   {
  SizeF resized;
 
  resized.SetSize(kTrivial, 0.f);
  EXPECT_EQ(SizeF(kTrivial, 0.f), resized);
 
  resized.SetSize(0.f, kTrivial);
  EXPECT_EQ(SizeF(0.f, kTrivial), resized);
}

TEST() [47/67]

gfx::TEST	(	SizeTest	,
		Enlarge
	)

Definition at line 127 of file size_unittest.cc.

                        {
  Size test(3, 4);
  test.Enlarge(5, -8);
  EXPECT_EQ(test, Size(8, -4));
}

TEST() [48/67]

gfx::TEST	(	SizeTest	,
		IntegerOverflow
	)

Definition at line 133 of file size_unittest.cc.

                                {
  int int_max = std::numeric_limits<int>::max();
  int int_min = std::numeric_limits<int>::min();
 
  Size max_size(int_max, int_max);
  Size min_size(int_min, int_min);
  Size test;
 
  test = Size();
  test.Enlarge(int_max, int_max);
  EXPECT_EQ(test, max_size);
 
  test = Size();
  test.Enlarge(int_min, int_min);
  EXPECT_EQ(test, min_size);
 
  test = Size(10, 20);
  test.Enlarge(int_max, int_max);
  EXPECT_EQ(test, max_size);
 
  test = Size(-10, -20);
  test.Enlarge(int_min, int_min);
  EXPECT_EQ(test, min_size);
}

TEST() [49/67]

gfx::TEST	(	SizeTest	,
		OperatorAddOverflow
	)

Definition at line 271 of file size_unittest.cc.

                                    {
  int int_max = std::numeric_limits<int>::max();
 
  Size lhs(int_max, int_max);
  Size rhs(int_max, int_max);
  EXPECT_EQ(Size(int_max, int_max), lhs + rhs);
}

TEST() [50/67]

gfx::TEST	(	SizeTest	,
		OperatorAddSub
	)

Definition at line 253 of file size_unittest.cc.

                               {
  Size lhs(100, 20);
  Size rhs(50, 10);
 
  lhs += rhs;
  EXPECT_EQ(Size(150, 30), lhs);
 
  lhs = Size(100, 20);
  EXPECT_EQ(Size(150, 30), lhs + rhs);
 
  lhs = Size(100, 20);
  lhs -= rhs;
  EXPECT_EQ(Size(50, 10), lhs);
 
  lhs = Size(100, 20);
  EXPECT_EQ(Size(50, 10), lhs - rhs);
}

TEST() [51/67]

gfx::TEST	(	SizeTest	,
		OperatorCompare
	)

Definition at line 290 of file size_unittest.cc.

                                {
  Size lhs(100, 20);
  Size rhs(50, 10);
 
  EXPECT_TRUE(lhs != rhs);
  EXPECT_FALSE(lhs == rhs);
 
  rhs = Size(100, 20);
  EXPECT_TRUE(lhs == rhs);
  EXPECT_FALSE(lhs != rhs);
}

TEST() [52/67]

gfx::TEST	(	SizeTest	,
		OperatorSubClampAtZero
	)

Definition at line 279 of file size_unittest.cc.

                                       {
  Size lhs(10, 10);
  Size rhs(100, 100);
  EXPECT_EQ(Size(0, 0), lhs - rhs);
 
  lhs = Size(10, 10);
  rhs = Size(100, 100);
  lhs -= rhs;
  EXPECT_EQ(Size(0, 0), lhs);
}

TEST() [53/67]

gfx::TEST	(	SizeTest	,
		StaysSmall
	)

Definition at line 249 of file size_unittest.cc.

                           {
  EXPECT_EQ(2 * sizeof(float), sizeof(SizeF));
}

TEST() [54/67]

gfx::TEST	(	SizeTest	,
		ToCeiledSize
	)

Definition at line 47 of file size_unittest.cc.

                             {
  EXPECT_EQ(Size(0, 0), ToCeiledSize(SizeF(0, 0)));
  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.0001f, 0.0001f)));
  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.4999f, 0.4999f)));
  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.5f, 0.5f)));
  EXPECT_EQ(Size(1, 1), ToCeiledSize(SizeF(0.9999f, 0.9999f)));
 
  EXPECT_EQ(Size(10, 10), ToCeiledSize(SizeF(10, 10)));
  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.0001f, 10.0001f)));
  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.4999f, 10.4999f)));
  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.5f, 10.5f)));
  EXPECT_EQ(Size(11, 11), ToCeiledSize(SizeF(10.9999f, 10.9999f)));
}

TEST() [55/67]

gfx::TEST	(	SizeTest	,
		ToFlooredSize
	)

Definition at line 33 of file size_unittest.cc.

                              {
  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0, 0)));
  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.0001f, 0.0001f)));
  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.4999f, 0.4999f)));
  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.5f, 0.5f)));
  EXPECT_EQ(Size(0, 0), ToFlooredSize(SizeF(0.9999f, 0.9999f)));
 
  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10, 10)));
  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.0001f, 10.0001f)));
  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.4999f, 10.4999f)));
  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.5f, 10.5f)));
  EXPECT_EQ(Size(10, 10), ToFlooredSize(SizeF(10.9999f, 10.9999f)));
}

TEST() [56/67]

gfx::TEST	(	SizeTest	,
		ToRoundedSize
	)

Definition at line 61 of file size_unittest.cc.

                              {
  EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0, 0)));
  EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0.0001f, 0.0001f)));
  EXPECT_EQ(Size(0, 0), ToRoundedSize(SizeF(0.4999f, 0.4999f)));
  EXPECT_EQ(Size(1, 1), ToRoundedSize(SizeF(0.5f, 0.5f)));
  EXPECT_EQ(Size(1, 1), ToRoundedSize(SizeF(0.9999f, 0.9999f)));
 
  EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10, 10)));
  EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10.0001f, 10.0001f)));
  EXPECT_EQ(Size(10, 10), ToRoundedSize(SizeF(10.4999f, 10.4999f)));
  EXPECT_EQ(Size(11, 11), ToRoundedSize(SizeF(10.5f, 10.5f)));
  EXPECT_EQ(Size(11, 11), ToRoundedSize(SizeF(10.9999f, 10.9999f)));
}

TEST() [57/67]

gfx::TEST	(	SizeTest	,
		ToSizeF
	)

Definition at line 22 of file size_unittest.cc.

                        {
  // Check that explicit conversion from integer to float compiles.
  Size a(10, 20);
  float width = TestSizeF(gfx::SizeF(a));
  EXPECT_EQ(width, a.width());
 
  SizeF b(10, 20);
 
  EXPECT_EQ(b, gfx::SizeF(a));
}

TEST() [58/67]

gfx::TEST	(	SizeTest	,
		TrivialDimensionTests
	)

Definition at line 159 of file size_unittest.cc.

                                      {
  const float clearly_trivial = kTrivial / 2.f;
  const float massize_dimension = 4e13f;
 
  // First, using the constructor.
  EXPECT_TRUE(SizeF(clearly_trivial, 1.f).IsEmpty());
  EXPECT_TRUE(SizeF(.01f, clearly_trivial).IsEmpty());
  EXPECT_TRUE(SizeF(0.f, 0.f).IsEmpty());
  EXPECT_FALSE(SizeF(.01f, .01f).IsEmpty());
 
  // Then use the setter.
  SizeF test(2.f, 1.f);
  EXPECT_FALSE(test.IsEmpty());
 
  test.SetSize(clearly_trivial, 1.f);
  EXPECT_TRUE(test.IsEmpty());
 
  test.SetSize(.01f, clearly_trivial);
  EXPECT_TRUE(test.IsEmpty());
 
  test.SetSize(0.f, 0.f);
  EXPECT_TRUE(test.IsEmpty());
 
  test.SetSize(.01f, .01f);
  EXPECT_FALSE(test.IsEmpty());
 
  // Now just one dimension at a time.
  test.set_width(clearly_trivial);
  EXPECT_TRUE(test.IsEmpty());
 
  test.set_width(massize_dimension);
  test.set_height(clearly_trivial);
  EXPECT_TRUE(test.IsEmpty());
 
  test.set_width(clearly_trivial);
  test.set_height(massize_dimension);
  EXPECT_TRUE(test.IsEmpty());
 
  test.set_width(2.f);
  EXPECT_FALSE(test.IsEmpty());
}

TEST() [59/67]

gfx::TEST	(	Vector2dTest	,
		Add
	)

Definition at line 38 of file vector2d_unittest.cc.

                        {
  Vector2d i1(3, 5);
  Vector2d i2(4, -1);
 
  const struct {
    Vector2d expected;
    Vector2d actual;
  } int_tests[] = {{Vector2d(3, 5), i1 + Vector2d()},
                   {Vector2d(3 + 4, 5 - 1), i1 + i2},
                   {Vector2d(3 - 4, 5 + 1), i1 - i2}};
 
  for (size_t i = 0; i < size(int_tests); ++i)
    EXPECT_EQ(int_tests[i].expected.ToString(), int_tests[i].actual.ToString());
 
  Vector2dF f1(3.1f, 5.1f);
  Vector2dF f2(4.3f, -1.3f);
 
  const struct {
    Vector2dF expected;
    Vector2dF actual;
  } float_tests[] = {{Vector2dF(3.1F, 5.1F), f1 + Vector2d()},
                     {Vector2dF(3.1F, 5.1F), f1 + Vector2dF()},
                     {Vector2dF(3.1f + 4.3f, 5.1f - 1.3f), f1 + f2},
                     {Vector2dF(3.1f - 4.3f, 5.1f + 1.3f), f1 - f2}};
 
  for (size_t i = 0; i < size(float_tests); ++i)
    EXPECT_EQ(float_tests[i].expected.ToString(),
              float_tests[i].actual.ToString());
}

TEST() [60/67]

gfx::TEST	(	Vector2dTest	,
		ClampVector2d
	)

Definition at line 176 of file vector2d_unittest.cc.

                                  {
  Vector2d a;
 
  a = Vector2d(3, 5);
  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
  a.SetToMax(Vector2d(2, 4));
  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
  a.SetToMax(Vector2d(3, 5));
  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
  a.SetToMax(Vector2d(4, 2));
  EXPECT_EQ(Vector2d(4, 5).ToString(), a.ToString());
  a.SetToMax(Vector2d(8, 10));
  EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
 
  a.SetToMin(Vector2d(9, 11));
  EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
  a.SetToMin(Vector2d(8, 10));
  EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
  a.SetToMin(Vector2d(11, 9));
  EXPECT_EQ(Vector2d(8, 9).ToString(), a.ToString());
  a.SetToMin(Vector2d(7, 11));
  EXPECT_EQ(Vector2d(7, 9).ToString(), a.ToString());
  a.SetToMin(Vector2d(3, 5));
  EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
}

TEST() [61/67]

gfx::TEST	(	Vector2dTest	,
		ClampVector2dF
	)

Definition at line 202 of file vector2d_unittest.cc.

                                   {
  Vector2dF a;
 
  a = Vector2dF(3.5f, 5.5f);
  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(Vector2dF(2.5f, 4.5f));
  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(Vector2dF(3.5f, 5.5f));
  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(Vector2dF(4.5f, 2.5f));
  EXPECT_EQ(Vector2dF(4.5f, 5.5f).ToString(), a.ToString());
  a.SetToMax(Vector2dF(8.5f, 10.5f));
  EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
 
  a.SetToMin(Vector2dF(9.5f, 11.5f));
  EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
  a.SetToMin(Vector2dF(8.5f, 10.5f));
  EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
  a.SetToMin(Vector2dF(11.5f, 9.5f));
  EXPECT_EQ(Vector2dF(8.5f, 9.5f).ToString(), a.ToString());
  a.SetToMin(Vector2dF(7.5f, 11.5f));
  EXPECT_EQ(Vector2dF(7.5f, 9.5f).ToString(), a.ToString());
  a.SetToMin(Vector2dF(3.5f, 5.5f));
  EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
}

TEST() [62/67]

gfx::TEST	(	Vector2dTest	,
		ConversionToFloat
	)

Definition at line 20 of file vector2d_unittest.cc.

                                      {
  Vector2d i(3, 4);
  Vector2dF f = i;
  EXPECT_EQ(i, f);
}

TEST() [63/67]

gfx::TEST	(	Vector2dTest	,
		IntegerOverflow
	)

Definition at line 228 of file vector2d_unittest.cc.

                                    {
  int int_max = std::numeric_limits<int>::max();
  int int_min = std::numeric_limits<int>::min();
 
  Vector2d max_vector(int_max, int_max);
  Vector2d min_vector(int_min, int_min);
  Vector2d test;
 
  test = Vector2d();
  test += Vector2d(int_max, int_max);
  EXPECT_EQ(test, max_vector);
 
  test = Vector2d();
  test += Vector2d(int_min, int_min);
  EXPECT_EQ(test, min_vector);
 
  test = Vector2d(10, 20);
  test += Vector2d(int_max, int_max);
  EXPECT_EQ(test, max_vector);
 
  test = Vector2d(-10, -20);
  test += Vector2d(int_min, int_min);
  EXPECT_EQ(test, min_vector);
 
  test = Vector2d();
  test -= Vector2d(int_max, int_max);
  EXPECT_EQ(test, Vector2d(-int_max, -int_max));
 
  test = Vector2d();
  test -= Vector2d(int_min, int_min);
  EXPECT_EQ(test, max_vector);
 
  test = Vector2d(10, 20);
  test -= Vector2d(int_min, int_min);
  EXPECT_EQ(test, max_vector);
 
  test = Vector2d(-10, -20);
  test -= Vector2d(int_max, int_max);
  EXPECT_EQ(test, min_vector);
}

TEST() [64/67]

gfx::TEST	(	Vector2dTest	,
		IsZero
	)

Definition at line 26 of file vector2d_unittest.cc.

                           {
  Vector2d int_zero(0, 0);
  Vector2d int_nonzero(2, -2);
  Vector2dF float_zero(0, 0);
  Vector2dF float_nonzero(0.1f, -0.1f);
 
  EXPECT_TRUE(int_zero.IsZero());
  EXPECT_FALSE(int_nonzero.IsZero());
  EXPECT_TRUE(float_zero.IsZero());
  EXPECT_FALSE(float_nonzero.IsZero());
}

TEST() [65/67]

gfx::TEST	(	Vector2dTest	,
		Length
	)

Definition at line 135 of file vector2d_unittest.cc.

                           {
  int int_values[][2] = {
      {0, 0}, {10, 20}, {20, 10}, {-10, -20}, {-20, 10}, {10, -20},
  };
 
  for (size_t i = 0; i < size(int_values); ++i) {
    int v0 = int_values[i][0];
    int v1 = int_values[i][1];
    double length_squared =
        static_cast<double>(v0) * v0 + static_cast<double>(v1) * v1;
    double length = std::sqrt(length_squared);
    Vector2d vector(v0, v1);
    EXPECT_EQ(static_cast<float>(length_squared), vector.LengthSquared());
    EXPECT_EQ(static_cast<float>(length), vector.Length());
  }
 
  float float_values[][2] = {
      {0, 0},
      {10.5f, 20.5f},
      {20.5f, 10.5f},
      {-10.5f, -20.5f},
      {-20.5f, 10.5f},
      {10.5f, -20.5f},
      // A large vector that fails if the Length function doesn't use
      // double precision internally.
      {1236278317862780234892374893213178027.12122348904204230f,
       335890352589839028212313231225425134332.38123f},
  };
 
  for (size_t i = 0; i < size(float_values); ++i) {
    double v0 = float_values[i][0];
    double v1 = float_values[i][1];
    double length_squared =
        static_cast<double>(v0) * v0 + static_cast<double>(v1) * v1;
    double length = std::sqrt(length_squared);
    Vector2dF vector(v0, v1);
    EXPECT_DOUBLE_EQ(length_squared, vector.LengthSquared());
    EXPECT_FLOAT_EQ(static_cast<float>(length), vector.Length());
  }
}

TEST() [66/67]

gfx::TEST	(	Vector2dTest	,
		Negative
	)

Definition at line 68 of file vector2d_unittest.cc.

                             {
  const struct {
    Vector2d expected;
    Vector2d actual;
  } int_tests[] = {{Vector2d(0, 0), -Vector2d(0, 0)},
                   {Vector2d(-3, -3), -Vector2d(3, 3)},
                   {Vector2d(3, 3), -Vector2d(-3, -3)},
                   {Vector2d(-3, 3), -Vector2d(3, -3)},
                   {Vector2d(3, -3), -Vector2d(-3, 3)}};
 
  for (size_t i = 0; i < size(int_tests); ++i)
    EXPECT_EQ(int_tests[i].expected.ToString(), int_tests[i].actual.ToString());
 
  const struct {
    Vector2dF expected;
    Vector2dF actual;
  } float_tests[] = {{Vector2dF(0, 0), -Vector2d(0, 0)},
                     {Vector2dF(-0.3f, -0.3f), -Vector2dF(0.3f, 0.3f)},
                     {Vector2dF(0.3f, 0.3f), -Vector2dF(-0.3f, -0.3f)},
                     {Vector2dF(-0.3f, 0.3f), -Vector2dF(0.3f, -0.3f)},
                     {Vector2dF(0.3f, -0.3f), -Vector2dF(-0.3f, 0.3f)}};
 
  for (size_t i = 0; i < size(float_tests); ++i)
    EXPECT_EQ(float_tests[i].expected.ToString(),
              float_tests[i].actual.ToString());
}

TEST() [67/67]

gfx::TEST	(	Vector2dTest	,
		Scale
	)

Definition at line 95 of file vector2d_unittest.cc.

                          {
  float double_values[][4] = {
      {4.5f, 1.2f, 3.3f, 5.6f},  {4.5f, -1.2f, 3.3f, 5.6f},
      {4.5f, 1.2f, 3.3f, -5.6f}, {4.5f, 1.2f, -3.3f, -5.6f},
      {-4.5f, 1.2f, 3.3f, 5.6f}, {-4.5f, 1.2f, 0, 5.6f},
      {-4.5f, 1.2f, 3.3f, 0},    {4.5f, 0, 3.3f, 5.6f},
      {0, 1.2f, 3.3f, 5.6f}};
 
  for (size_t i = 0; i < size(double_values); ++i) {
    Vector2dF v(double_values[i][0], double_values[i][1]);
    v.Scale(double_values[i][2], double_values[i][3]);
    EXPECT_EQ(v.x(), double_values[i][0] * double_values[i][2]);
    EXPECT_EQ(v.y(), double_values[i][1] * double_values[i][3]);
 
    Vector2dF v2 =
        ScaleVector2d(gfx::Vector2dF(double_values[i][0], double_values[i][1]),
                      double_values[i][2], double_values[i][3]);
    EXPECT_EQ(double_values[i][0] * double_values[i][2], v2.x());
    EXPECT_EQ(double_values[i][1] * double_values[i][3], v2.y());
  }
 
  float single_values[][3] = {
      {4.5f, 1.2f, 3.3f},  {4.5f, -1.2f, 3.3f}, {4.5f, 1.2f, 3.3f},
      {4.5f, 1.2f, -3.3f}, {-4.5f, 1.2f, 3.3f}, {-4.5f, 1.2f, 0},
      {-4.5f, 1.2f, 3.3f}, {4.5f, 0, 3.3f},     {0, 1.2f, 3.3f}};
 
  for (size_t i = 0; i < size(single_values); ++i) {
    Vector2dF v(single_values[i][0], single_values[i][1]);
    v.Scale(single_values[i][2]);
    EXPECT_EQ(v.x(), single_values[i][0] * single_values[i][2]);
    EXPECT_EQ(v.y(), single_values[i][1] * single_values[i][2]);
 
    Vector2dF v2 =
        ScaleVector2d(gfx::Vector2dF(double_values[i][0], double_values[i][1]),
                      double_values[i][2]);
    EXPECT_EQ(single_values[i][0] * single_values[i][2], v2.x());
    EXPECT_EQ(single_values[i][1] * single_values[i][2], v2.y());
  }
}

ToCeiledPoint()

GFX_EXPORT Point gfx::ToCeiledPoint

(

const PointF &

point

)

Definition at line 15 of file point_conversions.cc.

                                         {
  return Point(base::ClampCeil(point.x()), base::ClampCeil(point.y()));
}

ToCeiledSize()

GFX_EXPORT Size gfx::ToCeiledSize

(

const SizeF &

size

)

Definition at line 15 of file size_conversions.cc.

                                     {
  return Size(base::ClampCeil(size.width()), base::ClampCeil(size.height()));
}

ToCeiledVector2d()

GFX_EXPORT Vector2d gfx::ToCeiledVector2d

(

const Vector2dF &

vector2d

)

Definition at line 16 of file vector2d_conversions.cc.

                                                     {
  return Vector2d(base::ClampCeil(vector2d.x()), base::ClampCeil(vector2d.y()));
}

ToEnclosedRect()

GFX_EXPORT Rect gfx::ToEnclosedRect

(

const RectF &

rect

)

Definition at line 51 of file rect_conversions.cc.

                                       {
  Rect result;
  result.SetByBounds(base::ClampCeil(rect.x()), base::ClampCeil(rect.y()),
                     base::ClampFloor(rect.right()),
                     base::ClampFloor(rect.bottom()));
  return result;
}

ToEnclosedRectIgnoringError()

GFX_EXPORT Rect gfx::ToEnclosedRectIgnoringError	(	const RectF &	r,
		float	error
	)

Definition at line 59 of file rect_conversions.cc.

                                                              {
  int left = CeilIgnoringError(r.x(), error);
  int right = r.width() ? FloorIgnoringError(r.right(), error) : left;
  int top = CeilIgnoringError(r.y(), error);
  int bottom = r.height() ? FloorIgnoringError(r.bottom(), error) : top;
 
  Rect result;
  result.SetByBounds(left, top, right, bottom);
  return result;
}

ToEnclosingRect()

GFX_EXPORT Rect gfx::ToEnclosingRect

(

const RectF &

r

)

Definition at line 29 of file rect_conversions.cc.

                                     {
  int left = base::ClampFloor(r.x());
  int right = r.width() ? base::ClampCeil(r.right()) : left;
  int top = base::ClampFloor(r.y());
  int bottom = r.height() ? base::ClampCeil(r.bottom()) : top;
 
  Rect result;
  result.SetByBounds(left, top, right, bottom);
  return result;
}

ToEnclosingRectIgnoringError()

GFX_EXPORT Rect gfx::ToEnclosingRectIgnoringError	(	const RectF &	r,
		float	error
	)

Definition at line 40 of file rect_conversions.cc.

                                                               {
  int left = FloorIgnoringError(r.x(), error);
  int right = r.width() ? CeilIgnoringError(r.right(), error) : left;
  int top = FloorIgnoringError(r.y(), error);
  int bottom = r.height() ? CeilIgnoringError(r.bottom(), error) : top;
 
  Rect result;
  result.SetByBounds(left, top, right, bottom);
  return result;
}

ToFlooredPoint()

GFX_EXPORT Point gfx::ToFlooredPoint

(

const PointF &

point

)

Definition at line 11 of file point_conversions.cc.

                                          {
  return Point(base::ClampFloor(point.x()), base::ClampFloor(point.y()));
}

ToFlooredRectDeprecated()

GFX_EXPORT Rect gfx::ToFlooredRectDeprecated

(

const RectF &

rect

)

Definition at line 121 of file rect_conversions.cc.

                                                {
  return Rect(base::ClampFloor(rect.x()), base::ClampFloor(rect.y()),
              base::ClampFloor(rect.width()), base::ClampFloor(rect.height()));
}

ToFlooredSize()

GFX_EXPORT Size gfx::ToFlooredSize

(

const SizeF &

size

)

Definition at line 11 of file size_conversions.cc.

                                      {
  return Size(base::ClampFloor(size.width()), base::ClampFloor(size.height()));
}

ToFlooredVector2d()

GFX_EXPORT Vector2d gfx::ToFlooredVector2d

(

const Vector2dF &

vector2d

)

Definition at line 11 of file vector2d_conversions.cc.

                                                      {
  return Vector2d(base::ClampFloor(vector2d.x()),
                  base::ClampFloor(vector2d.y()));
}

ToNearestRect()

GFX_EXPORT Rect gfx::ToNearestRect

(

const RectF &

rect

)

Definition at line 70 of file rect_conversions.cc.

                                      {
  float float_min_x = rect.x();
  float float_min_y = rect.y();
  float float_max_x = rect.right();
  float float_max_y = rect.bottom();
 
  int min_x = base::ClampRound(float_min_x);
  int min_y = base::ClampRound(float_min_y);
  int max_x = base::ClampRound(float_max_x);
  int max_y = base::ClampRound(float_max_y);
 
  // If these DCHECKs fail, you're using the wrong method, consider using
  // ToEnclosingRect or ToEnclosedRect instead.
  BASE_DCHECK(std::abs(min_x - float_min_x) < 0.01f);
  BASE_DCHECK(std::abs(min_y - float_min_y) < 0.01f);
  BASE_DCHECK(std::abs(max_x - float_max_x) < 0.01f);
  BASE_DCHECK(std::abs(max_y - float_max_y) < 0.01f);
 
  Rect result;
  result.SetByBounds(min_x, min_y, max_x, max_y);
 
  return result;
}

ToRoundedPoint()

GFX_EXPORT Point gfx::ToRoundedPoint

(

const PointF &

point

)

Definition at line 19 of file point_conversions.cc.

                                          {
  return Point(base::ClampRound(point.x()), base::ClampRound(point.y()));
}

ToRoundedRect()

GFX_EXPORT gfx::Rect gfx::ToRoundedRect

(

const gfx::RectF &

rect

)

Definition at line 111 of file rect_conversions.cc.

                                            {
  int left = base::ClampRound(rect.x());
  int top = base::ClampRound(rect.y());
  int right = base::ClampRound(rect.right());
  int bottom = base::ClampRound(rect.bottom());
  gfx::Rect result;
  result.SetByBounds(left, top, right, bottom);
  return result;
}

ToRoundedSize()

GFX_EXPORT Size gfx::ToRoundedSize

(

const SizeF &

size

)

Definition at line 19 of file size_conversions.cc.

                                      {
  return Size(base::ClampRound(size.width()), base::ClampRound(size.height()));
}

ToRoundedVector2d()

GFX_EXPORT Vector2d gfx::ToRoundedVector2d

(

const Vector2dF &

vector2d

)

Definition at line 20 of file vector2d_conversions.cc.

                                                      {
  return Vector2d(base::ClampRound(vector2d.x()),
                  base::ClampRound(vector2d.y()));
}

UnionRects() [1/2]

GFX_EXPORT Rect gfx::UnionRects	(	const Rect &	a,
		const Rect &	b
	)

Definition at line 324 of file rect.cc.

                                              {
  Rect result = a;
  result.Union(b);
  return result;
}

UnionRects() [2/2]

GFX_EXPORT RectF gfx::UnionRects	(	const RectF &	a,
		const RectF &	b
	)

Definition at line 242 of file rect_f.cc.

                                                 {
  RectF result = a;
  result.Union(b);
  return result;
}

Variable Documentation

kNullCursor

const gfx::NativeCursor gfx::kNullCursor = static_cast<gfx::NativeCursor>(nullptr)

Definition at line 233 of file native_widget_types.h.