CRect
Class
Similar to a Windows RECT
structure.
class CRect : public tagRECT
Name | Description |
---|---|
CRect::CRect |
Constructs a CRect object. |
Name | Description |
---|---|
CRect::BottomRight |
Returns the bottom-right point of CRect . |
CRect::CenterPoint |
Returns the centerpoint of CRect . |
CRect::CopyRect |
Copies the dimensions of a source rectangle to CRect . |
CRect::DeflateRect |
Decreases the width and height of CRect . |
CRect::EqualRect |
Determines whether CRect is equal to the given rectangle. |
CRect::Height |
Calculates the height of CRect . |
CRect::InflateRect |
Increases the width and height of CRect . |
CRect::IntersectRect |
Sets CRect equal to the intersection of two rectangles. |
CRect::IsRectEmpty |
Determines whether CRect is empty. CRect is empty if the width and/or height are 0. |
CRect::IsRectNull |
Determines whether the top , bottom , left , and right member variables are all equal to 0. |
CRect::MoveToX |
Moves CRect to the specified x-coordinate. |
CRect::MoveToXY |
Moves CRect to the specified x- and y-coordinates. |
CRect::MoveToY |
Moves CRect to the specified y-coordinate. |
CRect::NormalizeRect |
Standardizes the height and width of CRect . |
CRect::OffsetRect |
Moves CRect by the specified offsets. |
CRect::PtInRect |
Determines whether the specified point lies within CRect . |
CRect::SetRect |
Sets the dimensions of CRect . |
CRect::SetRectEmpty |
Sets CRect to an empty rectangle (all coordinates equal to 0). |
CRect::Size |
Calculates the size of CRect . |
CRect::SubtractRect |
Subtracts one rectangle from another. |
CRect::TopLeft |
Returns the top-left point of CRect . |
CRect::UnionRect |
Sets CRect equal to the union of two rectangles. |
CRect::Width |
Calculates the width of CRect . |
Name | Description |
---|---|
CRect::operator - |
Subtracts the given offsets from CRect or deflates CRect and returns the resulting CRect . |
CRect::operator LPCRECT |
Converts a CRect to an LPCRECT . |
CRect::operator LPRECT |
Converts a CRect to an LPRECT . |
CRect::operator != |
Determines whether CRect is not equal to a rectangle. |
CRect::operator & |
Creates the intersection of CRect and a rectangle and returns the resulting CRect . |
CRect::operator &= |
Sets CRect equal to the intersection of CRect and a rectangle. |
CRect::operator | |
Creates the union of CRect and a rectangle and returns the resulting CRect . |
CRect::operator |= |
Sets CRect equal to the union of CRect and a rectangle. |
CRect::operator + |
Adds the given offsets to CRect or inflates CRect and returns the resulting CRect . |
CRect::operator += |
Adds the specified offsets to CRect or inflates CRect . |
CRect::operator = |
Copies the dimensions of a rectangle to CRect . |
CRect::operator -= |
Subtracts the specified offsets from CRect or deflates CRect . |
CRect::operator == |
Determines whether CRect is equal to a rectangle. |
CRect
also includes member functions to manipulate CRect
objects and Windows RECT
structures.
A CRect
object can be passed as a function parameter wherever a RECT
structure, LPCRECT
, or LPRECT
can be passed.
Note
This class is derived from the tagRECT
structure. (The name tagRECT
is a less-commonly-used name for the RECT
structure.) This means that the data members (left
, top
, right
, and bottom
) of the RECT
structure are accessible data members of CRect
.
A CRect
contains member variables that define the top-left and bottom-right points of a rectangle.
When specifying a CRect
, you must be careful to construct it so that it is normalized — in other words, such that the value of the left coordinate is less than the right and the top is less than the bottom. For example, a top left of (10,10) and bottom right of (20,20) defines a normalized rectangle but a top left of (20,20) and bottom right of (10,10) defines a non-normalized rectangle. If the rectangle is not normalized, many CRect
member functions may return incorrect results. (See CRect::NormalizeRect
for a list of these functions.) Before you call a function that requires normalized rectangles, you can normalize non-normalized rectangles by calling the NormalizeRect
function.
Use caution when manipulating a CRect
with the CDC::DPtoLP
and CDC::LPtoDP
member functions. If the mapping mode of a display context is such that the y-extent is negative, as in MM_LOENGLISH
, then CDC::DPtoLP
will transform the CRect
so that its top is greater than the bottom. Functions such as Height
and Size
will then return negative values for the height of the transformed CRect
, and the rectangle will be non-normalized.
When using overloaded CRect
operators, the first operand must be a CRect
; the second can be either a RECT
structure or a CRect
object.
tagRECT
CRect
Header: atltypes.h
The coordinates are returned as a reference to a CPoint
object that is contained in CRect
.
CPoint& BottomRight() throw();
const CPoint& BottomRight() const throw();
The coordinates of the bottom-right corner of the rectangle.
You can use this function to either get or set the bottom-right corner of the rectangle. Set the corner by using this function on the left side of the assignment operator.
// use BottomRight() to retrieve the bottom
// right POINT
CRect rect(210, 150, 350, 900);
CPoint ptDown;
ptDown = rect.BottomRight();
// ptDown is now set to (350, 900)
ASSERT(ptDown == CPoint(350, 900));
// or, use BottomRight() to set the bottom
// right POINT
CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);
CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);
rect2.BottomRight() = ptLow;
// rect2 is now (10, 10, 180, 180)
ASSERT(rect2 == CRect(10, 10, 180, 180));
Calculates the centerpoint of CRect
by adding the left and right values and dividing by two, and adding the top and bottom values and dividing by two.
CPoint CenterPoint() const throw();
A CPoint
object that is the centerpoint of CRect
.
// Code from this OnPaint() implementation can be pasted into your own application
// to draw lines that would look like a letter "Y" within your dialog.
void CMyDlg::OnPaint()
{
CPaintDC dc(this);
// device context for painting
// get the size and position of the client area of
// your window
CRect rect;
GetClientRect(&rect);
// Move the current pen to the top left of the window. We call the
// TopLeft() member of CRect here and it returns a CPoint object we
// pass to the override of CDC::MoveTo() that accepts a CPoint.
dc.MoveTo(rect.TopLeft());
// Draw a line from the top left to the center of the window.
// CenterPoint() gives us the middle point of the window as a
// CPoint, and since CDC::LineTo() has an override that accepts a
// CPoint, we can just pass it along.
dc.LineTo(rect.CenterPoint());
// Now, draw a line to the top right of the window. There's no
// CRect member which returns a CPoint for the top right of the
// window, so we'll reference the CPoint members directly and call
// the CDC::LineTo() override which takes two integers.
dc.LineTo(rect.right, rect.top);
// The top part of the "Y" is drawn. Now, we'll draw the stem. We
// start from the center point.
dc.MoveTo(rect.CenterPoint());
// and then draw to the middle of the bottom edge of the window.
// We'll get the x-coordinate from the x member of the CPOINT
// returned by CenterPoint(), and the y value comes directly from
// the rect.
dc.LineTo(rect.CenterPoint().x, rect.bottom);
}
Copies the lpSrcRect
rectangle into CRect
.
void CopyRect(LPCRECT lpSrcRect) throw();
lpSrcRect
Points to the RECT
structure or CRect
object that is to be copied.
CRect rectSource(35, 10, 125, 10);
CRect rectDest;
rectDest.CopyRect(&rectSource);
// rectDest is now set to (35, 10, 125, 10)
RECT rectSource2;
rectSource2.left = 0;
rectSource2.top = 0;
rectSource2.bottom = 480;
rectSource2.right = 640;
rectDest.CopyRect(&rectSource2);
// works against RECT structures, too!
// rectDest is now set to (0, 0, 640, 480)
Constructs a CRect
object.
CRect() throw();
CRect(int l, int t, int r, int b) throw();
CRect(const RECT& srcRect) throw();
CRect(LPCRECT lpSrcRect) throw();
CRect(POINT point, SIZE size) throw();
CRect(POINT topLeft, POINT bottomRight) throw();
l
Specifies the left position of CRect
.
t
Specifies the top of CRect
.
r
Specifies the right position of CRect
.
b
Specifies the bottom of CRect
.
srcRect
Refers to the RECT
structure with the coordinates for CRect
.
lpSrcRect
Points to the RECT
structure with the coordinates for CRect
.
point
Specifies the origin point for the rectangle to be constructed. Corresponds to the top-left corner.
size
Specifies the displacement from the top-left corner to the bottom-right corner of the rectangle to be constructed.
topLeft
Specifies the top-left position of CRect
.
bottomRight
Specifies the bottom-right position of CRect
.
If no arguments are given, left
, top
, right
, and bottom
members are set to 0.
The CRect
(const RECT&
) and CRect
(LPCRECT
) constructors perform a CopyRect
. The other constructors initialize the member variables of the object directly.
// default constructor is equivalent to CRect(0, 0, 0, 0)
CRect emptyRect;
// four-integers are left, top, right, and bottom
CRect rect(0, 0, 100, 50);
ASSERT(rect.Width() == 100);
ASSERT(rect.Height() == 50);
// Initialize from RECT structure
RECT sdkRect;
sdkRect.left = 0;
sdkRect.top = 0;
sdkRect.right = 100;
sdkRect.bottom = 50;
CRect rect2(sdkRect);
// by reference
CRect rect3(&sdkRect);
// by address
ASSERT(rect2 == rect);
ASSERT(rect3 == rect);
// from a point and a size
CPoint pt(0, 0);
CSize sz(100, 50);
CRect rect4(pt, sz);
ASSERT(rect4 == rect2);
// from two points
CPoint ptBottomRight(100, 50);
CRect rect5(pt, ptBottomRight);
ASSERT(rect5 == rect4);
DeflateRect
deflates CRect
by moving its sides toward its center.
void DeflateRect(int x, int y) throw();
void DeflateRect(SIZE size) throw();
void DeflateRect(LPCRECT lpRect) throw();
void DeflateRect(int l, int t, int r, int b) throw();
x
Specifies the number of units to deflate the left and right sides of CRect
.
y
Specifies the number of units to deflate the top and bottom of CRect
.
size
A SIZE
or CSize
that specifies the number of units to deflate CRect
. The cx
value specifies the number of units to deflate the left and right sides and the cy
value specifies the number of units to deflate the top and bottom.
lpRect
Points to a RECT
structure or CRect
that specifies the number of units to deflate each side.
l
Specifies the number of units to deflate the left side of CRect
.
t
Specifies the number of units to deflate the top of CRect
.
r
Specifies the number of units to deflate the right side of CRect
.
b
Specifies the number of units to deflate the bottom of CRect
.
To do this, DeflateRect
adds units to the left and top and subtracts units from the right and bottom. The parameters of DeflateRect
are signed values; positive values deflate CRect
and negative values inflate it.
The first two overloads deflate both pairs of opposite sides of CRect
so that its total width is decreased by two times x
(or cx
) and its total height is decreased by two times y
(or cy
). The other two overloads deflate each side of CRect
independently of the others.
CRect rect(10, 10, 50, 50);
rect.DeflateRect(1, 2);
ASSERT(rect.left == 11 && rect.right == 49);
ASSERT(rect.top == 12 && rect.bottom == 48);
CRect rect2(10, 10, 50, 50);
CRect rectDeflate(1, 2, 3, 4);
rect2.DeflateRect(&rectDeflate);
ASSERT(rect2.left == 11 && rect2.right == 47);
ASSERT(rect2.top == 12 && rect2.bottom == 46);
Determines whether CRect
is equal to the given rectangle.
BOOL EqualRect(LPCRECT lpRect) const throw();
lpRect
Points to a RECT
structure or CRect
object that contains the upper-left and lower-right corner coordinates of a rectangle.
Nonzero if the two rectangles have the same top, left, bottom, and right values; otherwise 0.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1.EqualRect(rect2));
ASSERT(!rect1.EqualRect(rect3));
// works just fine against RECTs, as well
RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;
ASSERT(rect1.EqualRect(&test));
Calculates the height of CRect
by subtracting the top value from the bottom value.
int Height() const throw();
The height of CRect
.
The resulting value can be negative.
Note
The rectangle must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangle before calling this function.
CRect rect(20, 30, 80, 70);
int nHt = rect.Height();
// nHt is now 40
ASSERT(nHt == 40);
InflateRect
inflates CRect
by moving its sides away from its center.
void InflateRect(int x, int y) throw();
void InflateRect(SIZE size) throw();
void InflateRect(LPCRECT lpRect) throw();
void InflateRect(int l, int t, int r, int b) throw();
x
Specifies the number of units to inflate the left and right sides of CRect
.
y
Specifies the number of units to inflate the top and bottom of CRect
.
size
A SIZE
or CSize
that specifies the number of units to inflate CRect
. The cx
value specifies the number of units to inflate the left and right sides and the cy
value specifies the number of units to inflate the top and bottom.
lpRect
Points to a RECT
structure or CRect
that specifies the number of units to inflate each side.
l
Specifies the number of units to inflate the left side of CRect
.
t
Specifies the number of units to inflate the top of CRect
.
r
Specifies the number of units to inflate the right side of CRect
.
b
Specifies the number of units to inflate the bottom of CRect
.
To do this, InflateRect
subtracts units from the left and top and adds units to the right and bottom. The parameters of InflateRect
are signed values; positive values inflate CRect
and negative values deflate it.
The first two overloads inflate both pairs of opposite sides of CRect
so that its total width is increased by two times x
(or cx
) and its total height is increased by two times y
(or cy
). The other two overloads inflate each side of CRect
independently of the others.
CRect rect(0, 0, 300, 300);
rect.InflateRect(50, 200);
// rect is now (-50, -200, 350, 500)
ASSERT(rect == CRect(-50, -200, 350, 500));
Makes a CRect
equal to the intersection of two existing rectangles.
BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();
lpRect1
Points to a RECT
structure or CRect
object that contains a source rectangle.
lpRect2
Points to a RECT
structure or CRect
object that contains a source rectangle.
Nonzero if the intersection is not empty; 0 if the intersection is empty.
The intersection is the largest rectangle contained in both existing rectangles.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rectOne(125, 0, 150, 200);
CRect rectTwo(0, 75, 350, 95);
CRect rectInter;
rectInter.IntersectRect(rectOne, rectTwo);
ASSERT(rectInter == CRect(125, 75, 150, 95));
// operator &= can do the same task:
CRect rectInter2 = rectOne;
rectInter2 &= rectTwo;
ASSERT(rectInter2 == CRect(125, 75, 150, 95));
Determines whether CRect
is empty.
BOOL IsRectEmpty() const throw();
Nonzero if CRect
is empty; 0 if CRect
is not empty.
A rectangle is empty if the width and/or height are 0 or negative. Differs from IsRectNull
, which determines whether all coordinates of the rectangle are zero.
Note
The rectangle must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangle before calling this function.
CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectEmpty());
ASSERT(!rectSome.IsRectEmpty());
CRect rectEmpty(35, 35, 35, 35);
ASSERT(rectEmpty.IsRectEmpty());
Determines whether the top, left, bottom, and right values of CRect
are all equal to 0.
BOOL IsRectNull() const throw();
Nonzero if CRect
's top, left, bottom, and right values are all equal to 0; otherwise 0.
Differs from IsRectEmpty
, which determines whether the rectangle is empty.
CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectNull());
ASSERT(!rectSome.IsRectNull());
// note that null means _all_ zeros
CRect rectNotNull(0, 0, 35, 50);
ASSERT(!rectNotNull.IsRectNull());
Call this function to move the rectangle to the absolute x-coordinate specified by x
.
void MoveToX(int x) throw();
x
The absolute x-coordinate for the upper-left corner of the rectangle.
CRect rect(0, 0, 100, 100);
rect.MoveToX(10);
// rect is now (10, 0, 110, 100);
ASSERT(rect == CRect(10, 0, 110, 100));
Call this function to move the rectangle to the absolute x- and y-coordinates specified.
void MoveToXY(int x, int y) throw();
void MoveToXY(POINT point) throw();
x
The absolute x-coordinate for the upper-left corner of the rectangle.
y
The absolute y-coordinate for the upper-left corner of the rectangle.
point
A POINT
structure specifying the absolute upper-left corner of the rectangle.
CRect rect(0, 0, 100, 100);
rect.MoveToXY(10, 10);
// rect is now (10, 10, 110, 110);
ASSERT(rect == CRect(10, 10, 110, 110));
Call this function to move the rectangle to the absolute y-coordinate specified by y
.
void MoveToY(int y) throw();
y
The absolute y-coordinate for the upper-left corner of the rectangle.
CRect rect(0, 0, 100, 100);
rect.MoveToY(10);
// rect is now (0, 10, 100, 110);
ASSERT(rect == CRect(0, 10, 100, 110));
Normalizes CRect
so that both the height and width are positive.
void NormalizeRect() throw();
The rectangle is normalized for fourth-quadrant positioning, which Windows typically uses for coordinates. NormalizeRect
compares the top and bottom values, and swaps them if the top is greater than the bottom. Similarly, it swaps the left and right values if the left is greater than the right. This function is useful when dealing with different mapping modes and inverted rectangles.
Note
The following CRect
member functions require normalized rectangles in order to work properly: Height
, Width
, Size
, IsRectEmpty
, PtInRect
, EqualRect
, UnionRect
, IntersectRect
, SubtractRect
, operator ==
, operator !=
, operator |
, operator |=
, operator &
, and operator &=
.
CRect rect1(110, 100, 250, 310);
CRect rect2(250, 310, 110, 100);
rect1.NormalizeRect();
rect2.NormalizeRect();
ASSERT(rect1 == rect2);
Moves CRect
by the specified offsets.
void OffsetRect(int x, int y) throw();
void OffsetRect(POINT point) throw();
void OffsetRect(SIZE size) throw();
x
Specifies the amount to move left or right. It must be negative to move left.
y
Specifies the amount to move up or down. It must be negative to move up.
point
Contains a POINT
structure or CPoint
object specifying both dimensions by which to move.
size
Contains a SIZE
structure or CSize
object specifying both dimensions by which to move.
Moves CRect
x
units along the x-axis and y
units along the y-axis. The x
and y
parameters are signed values, so CRect
can be moved left or right and up or down.
CRect rect(0, 0, 35, 35);
rect.OffsetRect(230, 230);
// rect is now (230, 230, 265, 265)
ASSERT(rect == CRect(230, 230, 265, 265));
CRect::operator LPCRECT
Converts a CRect
to an LPCRECT
.
operator LPCRECT() const throw();
When you use this function, you don't need the address-of (&
) operator. This operator will be automatically used when you pass a CRect
object to a function that expects an LPCRECT
.
Converts a CRect
to an LPRECT
.
operator LPRECT() throw();
When you use this function, you don't need the address-of (&
) operator. This operator will be automatically used when you pass a CRect
object to a function that expects an LPRECT
.
See the example for CRect::operator LPCRECT
.
Assigns srcRect
to CRect
.
void operator=(const RECT& srcRect) throw();
srcRect
Refers to a source rectangle. Can be a RECT
or CRect
.
CRect rect(0, 0, 127, 168);
CRect rect2;
rect2 = rect;
ASSERT(rect2 == CRect(0, 0, 127, 168));
Determines whether rect
is equal to CRect
by comparing the coordinates of their upper-left and lower-right corners.
BOOL operator==(const RECT& rect) const throw();
rect
Refers to a source rectangle. Can be a RECT
or CRect
.
Nonzero if equal; otherwise 0.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1 == rect2);
// works just fine against RECTs, as well
RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;
ASSERT(rect1 == test);
Determines whether rect
is not equal to CRect
by comparing the coordinates of their upper-left and lower-right corners.
BOOL operator!=(const RECT& rect) const throw();
rect
Refers to a source rectangle. Can be a RECT
or CRect
.
Nonzero if not equal; otherwise 0.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1 != rect3);
// works just fine against RECTs, as well
RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;
ASSERT(rect3 != test);
The first two overloads move CRect
by the specified offsets.
void operator+=(POINT point) throw();
void operator+=(SIZE size) throw();
void operator+=(LPCRECT lpRect) throw();
point
A POINT
structure or CPoint
object that specifies the number of units to move the rectangle.
size
A SIZE
structure or CSize
object that specifies the number of units to move the rectangle.
lpRect
Points to a RECT
structure or CRect
object that contains the number of units to inflate each side of CRect
.
The parameter's x
and y
(or cx
and cy
) values are added to CRect
.
The third overload inflates CRect
by the number of units specified in each member of the parameter.
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect rect2(135, 300, 235, 400);
rect1 += pt;
ASSERT(rect1 == rect2);
The first two overloads move CRect
by the specified offsets.
void operator-=(POINT point) throw();
void operator-=(SIZE size) throw();
void operator-=(LPCRECT lpRect) throw();
point
A POINT
structure or CPoint
object that specifies the number of units to move the rectangle.
size
A SIZE
structure or CSize
object that specifies the number of units to move the rectangle.
lpRect
Points to a RECT
structure or CRect
object that contains the number of units to deflate each side of CRect
.
The parameter's x
and y
(or cx
and cy
) values are subtracted from CRect
.
The third overload deflates CRect
by the number of units specified in each member of the parameter. Note that this overload functions like DeflateRect
.
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
rect1 -= pt;
CRect rectResult(65, 170, 165, 270);
ASSERT(rect1 == rectResult);
Sets CRect
equal to the intersection of CRect
and rect
.
void operator&=(const RECT& rect) throw();
rect
Contains a RECT
or CRect
.
The intersection is the largest rectangle that is contained in both rectangles.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
See the example for CRect::IntersectRect
.
Sets CRect
equal to the union of CRect
and rect
.
void operator|=(const RECT& rect) throw();
rect
Contains a CRect
or RECT
.
The union is the smallest rectangle that contains both source rectangles.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
rect1 |= rect2;
CRect rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect1);
The first two overloads return a CRect
object that is equal to CRect
displaced by the specified offsets.
CRect operator+(POINT point) const throw();
CRect operator+(LPCRECT lpRect) const throw();
CRect operator+(SIZE size) const throw();
point
A POINT
structure or CPoint
object that specifies the number of units to move the return value.
size
A SIZE
structure or CSize
object that specifies the number of units to move the return value.
lpRect
Points to a RECT
structure or CRect
object that contains the number of units to inflate each side of the return value.
The CRect
resulting from moving or inflating CRect
by the number of units specified in the parameter.
The parameter's x
and y
(or cx
and cy
) parameters are added to CRect
's position.
The third overload returns a new CRect
that is equal to CRect
inflated by the number of units specified in each member of the parameter.
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect rect2;
rect2 = rect1 + pt;
CRect rectResult(135, 300, 235, 400);
ASSERT(rectResult == rect2);
The first two overloads return a CRect
object that is equal to CRect
displaced by the specified offsets.
CRect operator-(POINT point) const throw();
CRect operator-(SIZE size) const throw();
CRect operator-(LPCRECT lpRect) const throw();
point
A POINT
structure or CPoint
object that specifies the number of units to move the return value.
size
A SIZE
structure or CSize
object that specifies the number of units to move the return value.
lpRect
Points to a RECT
structure or CRect
object that contains the number of units to deflate each side of the return value.
The CRect
resulting from moving or deflating CRect
by the number of units specified in the parameter.
The parameter's x
and y
(or cx
and cy
) parameters are subtracted from CRect
's position.
The third overload returns a new CRect
that is equal to CRect
deflated by the number of units specified in each member of the parameter. Note that this overload functions like DeflateRect
, not SubtractRect
.
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect rect2;
rect2 = rect1 - pt;
CRect rectResult(65, 170, 165, 270);
ASSERT(rect2 == rectResult);
Returns a CRect
that is the intersection of CRect
and rect2.
CRect operator&(const RECT& rect2) const throw();
rect2
Contains a RECT
or CRect
.
A CRect
that is the intersection of CRect
and rect2
.
The intersection is the largest rectangle that is contained in both rectangles.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
CRect rect3;
rect3 = rect1 & rect2;
CRect rectResult(100, 100, 200, 200);
ASSERT(rectResult == rect3);
Returns a CRect
that is the union of CRect
and rect2
.
CRect operator|(const RECT&
rect2) const throw();
rect2
Contains a RECT
or CRect
.
A CRect
that is the union of CRect
and rect2
.
The union is the smallest rectangle that contains both rectangles.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
CRect rect3;
rect3 = rect1 | rect2;
CRect rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);
Determines whether the specified point lies within CRect
.
BOOL PtInRect(POINT point) const throw();
point
Contains a POINT
structure or CPoint
object.
Nonzero if the point lies within CRect
; otherwise 0.
A point is within CRect
if it lies on the left or top side or is within all four sides. A point on the right or bottom side is outside CRect
.
Note
The rectangle must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangle before calling this function.
CRect rect(5, 5, 100, 100);
CPoint pt1(35, 50);
CPoint pt2(125, 298);
// this is true, because pt1 is inside the rectangle
ASSERT(rect.PtInRect(pt1));
// this is NOT true, because pt2 is outside the rectangle
ASSERT(!rect.PtInRect(pt2));
// note that the right and the bottom aren't inside
ASSERT(!rect.PtInRect(CPoint(35, 100)));
ASSERT(!rect.PtInRect(CPoint(100, 98)));
// but the top and the left are inside
ASSERT(rect.PtInRect(CPoint(5, 65)));
ASSERT(rect.PtInRect(CPoint(88, 5)));
// and that PtInRect() works against a POINT, too
POINT pt;
pt.x = 35;
pt.y = 50;
ASSERT(rect.PtInRect(pt));
Sets the dimensions of CRect
to the specified coordinates.
void SetRect(int x1, int y1, int x2, int y2) throw();
x1
Specifies the x-coordinate of the upper-left corner.
y1
Specifies the y-coordinate of the upper-left corner.
x2
Specifies the x-coordinate of the lower-right corner.
y2
Specifies the y-coordinate of the lower-right corner.
CRect rect;
rect.SetRect(256, 256, 512, 512);
ASSERT(rect == CRect(256, 256, 512, 512));
Makes CRect
a null rectangle by setting all coordinates to zero.
void SetRectEmpty() throw();
CRect rect;
rect.SetRectEmpty();
// rect is now (0, 0, 0, 0)
ASSERT(rect.IsRectEmpty());
The cx
and cy
members of the return value contain the height and width of CRect
.
CSize Size() const throw();
A CSize
object that contains the size of CRect
.
Either the height or width can be negative.
Note
The rectangle must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangle before calling this function.
CRect rect(10, 10, 50, 50);
CSize sz = rect.Size();
ASSERT(sz.cx == 40 && sz.cy == 40);
Makes the dimensions of the CRect
equal to the subtraction of lpRectSrc2
from lpRectSrc1
.
BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();
lpRectSrc1
Points to the RECT
structure or CRect
object from which a rectangle is to be subtracted.
lpRectSrc2
Points to the RECT
structure or CRect
object that is to be subtracted from the rectangle pointed to by the lpRectSrc1
parameter.
Nonzero if the function is successful; otherwise 0.
The subtraction is the smallest rectangle that contains all of the points in lpRectScr1
that are not in the intersection of lpRectScr1
and lpRectScr2
.
The rectangle specified by lpRectSrc1
will be unchanged if the rectangle specified by lpRectSrc2
doesn't completely overlap the rectangle specified by lpRectSrc1
in at least one of the x- or y-directions.
For example, if lpRectSrc1
were (10,10, 100,100) and lpRectSrc2
were (50,50, 150,150), the rectangle pointed to by lpRectSrc1
would be unchanged when the function returned. If lpRectSrc1
were (10,10, 100,100) and lpRectSrc2
were (50,10, 150,150), however, the rectangle pointed to by lpRectSrc1
would contain the coordinates (10,10, 50,100) when the function returned.
SubtractRect
is not the same as operator - nor operator -=. Neither of these operators ever calls SubtractRect
.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
RECT rectOne;
RECT rectTwo;
rectOne.left = 10;
rectOne.top = 10;
rectOne.bottom = 100;
rectOne.right = 100;
rectTwo.left = 50;
rectTwo.top = 10;
rectTwo.bottom = 150;
rectTwo.right = 150;
CRect rectDiff;
rectDiff.SubtractRect(&rectOne, &rectTwo);
CRect rectResult(10, 10, 50, 100);
ASSERT(rectDiff == rectResult);
// works for CRect, too, since there is
// implicit CRect -> LPCRECT conversion
CRect rect1(10, 10, 100, 100);
CRect rect2(50, 10, 150, 150);
CRect rectOut;
rectOut.SubtractRect(rect1, rect2);
ASSERT(rectResult == rectOut);
The coordinates are returned as a reference to a CPoint
object that is contained in CRect
.
CPoint& TopLeft() throw();
const CPoint& TopLeft() const throw();
The coordinates of the top-left corner of the rectangle.
You can use this function to either get or set the top-left corner of the rectangle. Set the corner by using this function on the left side of the assignment operator.
See the example for CRect::CenterPoint
.
Makes the dimensions of CRect
equal to the union of the two source rectangles.
BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();
lpRect1
Points to a RECT
or CRect
that contains a source rectangle.
lpRect2
Points to a RECT
or CRect
that contains a source rectangle.
Nonzero if the union is not empty; 0 if the union is empty.
The union is the smallest rectangle that contains both source rectangles.
Windows ignores the dimensions of an empty rectangle; that is, a rectangle that has no height or has no width.
Note
Both of the rectangles must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangles before calling this function.
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
CRect rect3;
rect3.UnionRect(&rect1, &rect2);
CRect rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);
Calculates the width of CRect
by subtracting the left value from the right value.
int Width() const throw();
The width of CRect
.
The width can be negative.
Note
The rectangle must be normalized or this function may fail. You can call NormalizeRect
to normalize the rectangle before calling this function.
CRect rect(20, 30, 80, 70);
int nWid = rect.Width();
// nWid is now 60
ASSERT(nWid == 60);