CRect クラス

Windows の RECT 構造体と同様のものです。

構文

class CRect : public tagRECT

メンバー

パブリック コンストラクター

名前 説明
CRect::CRect CRect オブジェクトを構築します。

パブリック メソッド

名前 説明
CRect::BottomRight CRect の右下の点を返します。
CRect::CenterPoint CRect の中心点を返します。
CRect::CopyRect ソースの四角形のディメンションを CRect にコピーします。
CRect::DeflateRect CRect の幅と高さを小さくします。
CRect::EqualRect CRect が特定の四角形に等しいかどうかを判断します。
CRect::Height CRect の高さを計算します。
CRect::InflateRect CRect の幅と高さを大きくします。
CRect::IntersectRect CRect が 2 つの四角形の積集合に等しくなるように設定します。
CRect::IsRectEmpty CRect が空であるかどうかを判断します。 幅と高さのどちらかまたは両方が 0 の場合、CRect は空になります。
CRect::IsRectNull topbottomleft、および right の各メンバー変数がすべて 0 に等しいかどうかを判断します。
CRect::MoveToX 指定した X 座標に CRect を移動します。
CRect::MoveToXY 指定した X 座標と Y 座標に CRect を移動します。
CRect::MoveToY 指定した Y 座標に CRect を移動します。
CRect::NormalizeRect CRect の高さと幅を標準化します。
CRect::OffsetRect 特定のオフセットだけ CRect を移動します。
CRect::PtInRect 指定した点が CRect の内側にあるかどうかを判断します。
CRect::SetRect CRect のディメンションを設定します。
CRect::SetRectEmpty CRect を空の四角形 (すべての座標が 0 に等しい) に設定します。
CRect::Size CRect のサイズを計算します。
CRect::SubtractRect ある四角形を別の四角形から減算します。
CRect::TopLeft CRect の左上の点を返します。
CRect::UnionRect CRect が 2 つの四角形の和集合に等しくなるように設定します。
CRect::Width CRect の幅を計算します。

パブリック演算子

名前 説明
CRect::operator - 特定のオフセットを CRect から減算するか、または CRect を縮小し、結果として得られる CRect を返します。
CRect::operator LPCRECT CRectLPCRECT に変換します。
CRect::operator LPRECT CRectLPRECT に変換します。
CRect::operator != CRect が四角形に等しくないかどうかを判断します。
CRect::operator & CRect と四角形の積集合を作成し、結果として得られる CRect を返します。
CRect::operator &= CRectCRect と四角形の積集合に等しくなるように設定します。
CRect::operator | CRect と四角形の和集合を作成し、結果として得られる CRect を返します。
CRect::operator |= CRectCRect と四角形の和集合に等しくなるように設定します。
CRect::operator + 特定のオフセットを CRect に加算するか、または CRect を拡張し、結果として得られる CRect を返します。
CRect::operator += 特定のオフセットを CRect に加算するか、または CRect を拡張します。
CRect::operator = 四角形のディメンションを CRect にコピーします。
CRect::operator -= 特定のオフセットを CRect から減算するか、または CRect を縮小します。
CRect::operator == CRect が四角形に等しいかどうかを判断します。

解説

CRect には、CRect オブジェクトと Windows の RECT 構造体を操作するメンバー関数も含まれます。

RECT 構造体、LPCRECT、または LPRECT を渡すことができるときは常に、CRect オブジェクトを関数パラメーターとして渡すことができます。

Note

このクラスは、tagRECT 構造体から派生しています (tagRECTの名前は、RECT構造体にはあまり使われる名前ではありません)。つまり、RECT構造体のデータ メンバー (lefttoprightbottom) は、CRectのアクセス可能なデータ メンバーです。

CRect には、四角形の左上および右下の点を定義するメンバー変数が含まれています。

CRect を指定するときは、これが正規化されるように注意して作成する必要があります。つまり、左の座標の値が右の値より小さく、上の値が下の値よりも小さくなるようにします。 たとえば、左上 (10, 10) と右下 (20, 20) では正規化された四角形が定義されますが、左上 (20, 20) と右下 (10, 10) では正規化されていない四角形が定義されます。 四角形が正規化されていない場合、多くの CRect メンバー関数が正しくない結果を返す可能性があります (これらの関数の一覧については、 CRect::NormalizeRect を参照してください)。正規化された四角形を必要とする関数を呼び出す前に、 NormalizeRect 関数を呼び出すことによって、正規化されていない四角形を正規化できます。

CDC::DPtoLP および CDC::LPtoDP メンバー関数を使用して CRect を操作する場合は注意が必要です。 MM_LOENGLISH のように、たとえば表示コンテキストのマッピング モードで Y エクステントが負の値になる場合、CDC::DPtoLP により、上の値が下の値よりも大きくなるように CRect が変換されます。 これにより、HeightSize などの関数は、変換された CRect の高さに対して負の値を返し、四角形は正規化されません。

オーバーロードされた CRect 演算子を使用する場合、最初のオペランドは CRect である必要があります。2 番目のオペランドは RECT 構造体または CRect オブジェクトのいずれかになります。

継承階層

tagRECT

CRect

要件

ヘッダー: atltypes.h

CRect::BottomRight

座標は、CRect に含まれている CPoint オブジェクトへの参照として返されます。

CPoint& BottomRight() throw();
const CPoint& BottomRight() const throw();

戻り値

四角形の右下隅の座標です。

解説

この関数を使用すると、四角形の右下隅を取得または設定できます。 代入演算子の左側にあるこの関数を使用して、この隅を設定します。

// 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));

CRect::CenterPoint

左右の値を加算して 2 で除算し、上下の値を加算して 2 で除算することによって、CRect の中心点を計算します。

CPoint CenterPoint() const throw();

戻り値

CRect の中心点である CPoint オブジェクト。

// 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);
}

CRect::CopyRect

lpSrcRect 四角形を CRect にコピーします。

void CopyRect(LPCRECT lpSrcRect) throw();

パラメーター

lpSrcRect
コピーする RECT 構造体または CRect オブジェクトを指します。

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)

CRect::CRect

CRect オブジェクトを構築します。

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
CRect の左位置を指定します。

t
CRect の上位置を指定します。

r
CRect の右位置を指定します。

b
CRect の下位置を指定します。

srcRect
CRect の座標を持つ RECT 構造体を参照します。

lpSrcRect
CRect の座標を持つ RECT 構造体を指します。

point
作成する四角形の原点を指定します。 左上隅に相当します。

size
作成する四角形の左上隅から右下隅までの変位を指定します。

topLeft
CRect の左上位置を指定します。

bottomRight
CRect の右下位置を指定します。

解説

引数を指定しない場合、lefttopright、および bottom の各メンバーは 0 に設定されます。

CRect(const RECT&) コンストラクターと CRect(LPCRECT) コンストラクターでは、CopyRect を実行します。 その他のコンストラクターでは、オブジェクトのメンバー変数を直接初期化します。

// 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);

CRect::DeflateRect

DeflateRect では、各辺を中心に向かって移動することで CRect を縮小します。

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
CRect の左辺と右辺を縮小するユニットの数を指定します。

y
CRect の上辺と底辺を縮小するユニットの数を指定します。

size
CRect を縮小するユニットの数を指定する SIZE または CSizecx 値は、左辺と右辺を縮小するユニットの数を指定し、cy 値は、上辺と底辺を縮小するユニットの数を指定します。

lpRect
各辺を縮小するユニットの数を指定する RECT 構造体または CRect を指します。

l
CRect の左辺を縮小するユニットの数を指定します。

t
CRect の上辺を縮小するユニットの数を指定します。

r
CRect の右辺を縮小するユニットの数を指定します。

b
CRect の底辺を縮小するユニットの数を指定します。

解説

これを行うには、DeflateRect により、左と上のユニットを増やし、右と下のユニットを減らします。 DeflateRect のパラメーターは符号付きの値です。正の値の場合は CRect が縮小され、負の値の場合は拡張されます。

最初の 2 つのオーバーロードでは、CRect の向かい合う 2 組の辺を縮小し、幅の合計を 2 x x (または cx) だけ減少して、高さの合計を 2 x y (または cy) だけ減少します。 他の 2 つのオーバーロードでは、CRect のそれぞれの辺を互いに独立して縮小します。

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);

CRect::EqualRect

CRect が特定の四角形に等しいかどうかを判断します。

BOOL EqualRect(LPCRECT lpRect) const throw();

パラメーター

lpRect
四角形の左上隅と右下隅の座標を含む RECT 構造体または CRect オブジェクトを指します。

戻り値

2 つの四角形の上、左、下、および右の値が同じ場合は 0 以外の値。それ以外の場合は 0。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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));

CRect::Height

下の値から上の値を減算することで、CRect の高さを計算します。

int Height() const throw();

戻り値

CRect の高さ。

解説

結果として得られる値が負の値になる可能性があります。

Note

四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

CRect rect(20, 30, 80, 70);
int nHt = rect.Height();

// nHt is now 40
ASSERT(nHt == 40);

CRect::InflateRect

InflateRect では、各辺を中心から離れるように移動することで CRect を拡張します。

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
CRect の左辺と右辺を拡張するユニットの数を指定します。

y
CRect の上辺と底辺を拡張するユニットの数を指定します。

size
CRect を拡張するユニットの数を指定する SIZE または CSizecx 値は、左辺と右辺を拡張するユニットの数を指定し、cy 値は、上辺と底辺を拡張するユニットの数を指定します。

lpRect
各辺を拡張するユニットの数を指定する RECT 構造体または CRect を指します。

l
CRect の左辺を拡張するユニットの数を指定します。

t
CRect の上辺を拡張するユニットの数を指定します。

r
CRect の右辺を拡張するユニットの数を指定します。

b
CRect の底辺を拡張するユニットの数を指定します。

解説

これを行うには、InflateRect により、左と上のユニットを減らし、右と下のユニットを増やします。 InflateRect のパラメーターは符号付きの値です。正の値の場合は CRect が拡張され、負の値の場合は縮小されます。

最初の 2 つのオーバーロードでは、CRect の向かい合う 2 組の辺を拡張し、幅の合計を 2 x x (または cx) だけ増加して、高さの合計を 2 x y (または cy) だけ増加します。 他の 2 つのオーバーロードでは、CRect のそれぞれの辺を互いに独立して拡張します。

CRect rect(0, 0, 300, 300);
rect.InflateRect(50, 200);

// rect is now (-50, -200, 350, 500)
ASSERT(rect == CRect(-50, -200, 350, 500));

CRect::IntersectRect

CRect が 2 つの既存の四角形の積集合に等しくなるようにします。

BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

パラメーター

lpRect1
ソースの四角形を含む RECT 構造体または CRect オブジェクトを指します。

lpRect2
ソースの四角形を含む RECT 構造体または CRect オブジェクトを指します。

戻り値

積集合が空でない場合は 0 以外の値。積集合が空の場合は 0。

解説

積集合は、両方の既存の四角形に含まれている最大の四角形です。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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));

CRect::IsRectEmpty

CRect が空であるかどうかを判断します。

BOOL IsRectEmpty() const throw();

戻り値

CRect が空の場合は 0 以外の値。CRect が空でない場合は 0。

解説

幅と高さのどちらかまたは両方が 0 または負の値の場合、四角形は空になります。 IsRectNull (四角形のすべての座標が 0 であるかどうかを判断する) とは異なります。

Note

四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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());

CRect::IsRectNull

CRect の上、左、下、および右の値がすべて 0 に等しいかどうかを判断します。

BOOL IsRectNull() const throw();

戻り値

CRect の上、左、下、および右の値がすべて 0 に等しい場合は 0 以外の値。それ以外の場合は 0。

解説

IsRectEmpty (四角形が空であるかどうかを判断する) とは異なります。

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());

CRect::MoveToX

x によって指定された絶対 X 座標に四角形を移動するには、この関数を呼び出します。

void MoveToX(int x) throw();

パラメーター

x
四角形の左上隅の絶対 X 座標。

CRect rect(0, 0, 100, 100);
rect.MoveToX(10);

// rect is now (10, 0, 110, 100);
ASSERT(rect == CRect(10, 0, 110, 100));

CRect::MoveToXY

指定された絶対 Y 座標に四角形を移動するには、この関数を呼び出します。

void MoveToXY(int x, int y) throw();
void MoveToXY(POINT point) throw();

パラメーター

x
四角形の左上隅の絶対 X 座標。

y
四角形の左上隅の絶対 Y 座標。

point
四角形の絶対左上隅を指定する POINT 構造体。

CRect rect(0, 0, 100, 100);
rect.MoveToXY(10, 10);
// rect is now (10, 10, 110, 110);
ASSERT(rect == CRect(10, 10, 110, 110));

CRect::MoveToY

y によって指定された絶対 Y 座標に四角形を移動するには、この関数を呼び出します。

void MoveToY(int y) throw();

パラメーター

y
四角形の左上隅の絶対 Y 座標。

CRect rect(0, 0, 100, 100);
rect.MoveToY(10);
// rect is now (0, 10, 100, 110);
ASSERT(rect == CRect(0, 10, 100, 110));

CRect::NormalizeRect

高さと幅の両方が正の値になるように、CRect を正規化します。

void NormalizeRect() throw();

解説

四角形は 4 番目のクアドラントの配置に対して正規化されます。これは通常、Windows では座標に使用されます。 NormalizeRect では上下の値を比較し、上の値が上の値よりも大きい場合はそれらを入れ替えます。 同様に、左の値が右の値よりも大きい場合は、左右の値を入れ替えます。 この関数は、さまざまなマッピング モードおよび反転された四角形を処理する場合に便利です。

Note

CRect メンバー関数 HeightWidthSizeIsRectEmptyPtInRectEqualRectUnionRectIntersectRectSubtractRectoperator ==operator !=operator |operator |=operator &、および operator &= が適切に機能するには、正規化された四角形が必要です。

CRect rect1(110, 100, 250, 310);
CRect rect2(250, 310, 110, 100);
rect1.NormalizeRect();
rect2.NormalizeRect();
ASSERT(rect1 == rect2);

CRect::OffsetRect

特定のオフセットだけ CRect を移動します。

void OffsetRect(int x, int y) throw();
void OffsetRect(POINT point) throw();
void OffsetRect(SIZE size) throw();

パラメーター

x
左または右に移動する量を指定します。 左に移動するには、負の値である必要があります。

y
上または下に移動する量を指定します。 上に移動するには、負の値である必要があります。

point
移動に使用する両方のディメンションを指定する POINT 構造体または CPoint オブジェクトが含まれています。

size
移動に使用する両方のディメンションを指定する SIZE 構造体または CSize オブジェクトが含まれています。

解説

CRectx ユニットを X 軸に沿って、y ユニットを Y 軸に沿って移動します。 x パラメーターと y パラメーターは符号付きの値なので、CRect は左右または上下に移動できます。

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 CRectLPCRECT に変換します。

operator LPCRECT() const throw();

解説

この関数を使用する場合、address-of (&) 演算子は必要ありません。 この演算子は、LPCRECT を必要とする関数に CRect オブジェクトを渡すときに自動的に使用されます。

CRect::operator LPRECT

CRectLPRECT に変換します。

operator LPRECT() throw();

解説

この関数を使用する場合、address-of (&) 演算子は必要ありません。 この演算子は、LPRECT を必要とする関数に CRect オブジェクトを渡すときに自動的に使用されます。

CRect::operator LPCRECT の例を参照してください。

CRect::operator =

srcRectCRect に代入します。

void operator=(const RECT& srcRect) throw();

パラメーター

srcRect
ソースの四角形を参照します。 RECT または CRect になります。

CRect rect(0, 0, 127, 168);
CRect rect2;

rect2 = rect;
ASSERT(rect2 == CRect(0, 0, 127, 168));

CRect::operator ==

左上隅と右下隅の座標を比較することで、rectCRect に等しいかどうかを判断します。

BOOL operator==(const RECT& rect) const throw();

パラメーター

rect
ソースの四角形を参照します。 RECT または CRect になります。

戻り値

等しい場合は 0 以外。それ以外の場合は 0。

解説

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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);

CRect::operator !=

左上隅と右下隅の座標を比較することで、rectCRect に等しくないかどうかを判断します。

BOOL operator!=(const RECT& rect) const throw();

パラメーター

rect
ソースの四角形を参照します。 RECT または CRect になります。

戻り値

等しくない場合は 0 以外の値。それ以外の場合は 0。

解説

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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);

CRect::operator +=

最初の 2 つのオーバーロードでは、指定したオフセットだけ CRect を移動します。

void operator+=(POINT point) throw();
void operator+=(SIZE size) throw();
void operator+=(LPCRECT lpRect) throw();

パラメーター

point
四角形を移動するユニットの数を指定する POINT 構造体または CPoint オブジェクト。

size
四角形を移動するユニットの数を指定する SIZE 構造体または CSize オブジェクト。

lpRect
CRect の各辺を拡張するユニットの数を含む RECT 構造体または CRect オブジェクトを指します。

解説

パラメーターの xy (または cxcy) の各値が CRect に加算されます。

3 番目のオーバーロードでは、パラメーターの各メンバーで指定したユニットの数だけ CRect を拡張します。

CRect   rect1(100, 235, 200, 335);
CPoint  pt(35, 65);
CRect   rect2(135, 300, 235, 400);

rect1 += pt;
ASSERT(rect1 == rect2);

CRect::operator -=

最初の 2 つのオーバーロードでは、指定したオフセットだけ CRect を移動します。

void operator-=(POINT point) throw();
void operator-=(SIZE size) throw();
void operator-=(LPCRECT lpRect) throw();

パラメーター

point
四角形を移動するユニットの数を指定する POINT 構造体または CPoint オブジェクト。

size
四角形を移動するユニットの数を指定する SIZE 構造体または CSize オブジェクト。

lpRect
CRect の各辺を縮小するユニットの数を含む RECT 構造体または CRect オブジェクトを指します。

解説

パラメーターの xy (または cxcy) の各値が CRect から減算されます。

3 番目のオーバーロードでは、パラメーターの各メンバーで指定したユニットの数だけ CRect を縮小します。 このオーバーロードは、DeflateRect と同様に機能します。

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);

rect1 -= pt;
CRect   rectResult(65, 170, 165, 270);
ASSERT(rect1 == rectResult);

CRect::operator &=

CRectCRectrect の積集合に等しくなるように設定します。

void operator&=(const RECT& rect) throw();

パラメーター

rect
RECT または CRect が含まれています。

解説

積集合は、両方の四角形に含まれている最大の四角形です。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

CRect::IntersectRect の例を参照してください。

CRect::operator |=

CRectCRectrect の和集合に等しくなるように設定します。

void operator|=(const RECT& rect) throw();

パラメーター

rect
CRect または RECT が含まれています。

解説

和集合は、両方のソースの四角形を含む最小の四角形です。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);

rect1 |= rect2;
CRect   rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect1);

CRect::operator +

最初の 2 つのオーバーロードは、指定したオフセットだけ変位された CRect に等しい CRect オブジェクトを返します。

CRect operator+(POINT point) const throw();
CRect operator+(LPCRECT lpRect) const throw();
CRect operator+(SIZE size) const throw();

パラメーター

point
戻り値を移動するユニットの数を指定する POINT 構造体または CPoint オブジェクト。

size
戻り値を移動するユニットの数を指定する SIZE 構造体または CSize オブジェクト。

lpRect
戻り値の各辺を拡張するユニットの数を含む RECT 構造体または CRect オブジェクトを指します。

戻り値

パラメーターで指定したユニットの数だけ CRect を移動または拡張した結果として得られる CRect

解説

パラメーターの xy (または cxcy) の各パラメーターが CRect の位置に追加されます。

3 番目のオーバーロードは、パラメーターの各メンバーで指定したユニットの数だけ拡張された CRect に等しい、新しい CRect を返します。

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect   rect2;

rect2 = rect1 + pt;
CRect   rectResult(135, 300, 235, 400);
ASSERT(rectResult == rect2);

CRect::operator -

最初の 2 つのオーバーロードは、指定したオフセットだけ変位された CRect に等しい CRect オブジェクトを返します。

CRect operator-(POINT point) const throw();
CRect operator-(SIZE size) const throw();
CRect operator-(LPCRECT lpRect) const throw();

パラメーター

point
戻り値を移動するユニットの数を指定する POINT 構造体または CPoint オブジェクト。

size
戻り値を移動するユニットの数を指定する SIZE 構造体または CSize オブジェクト。

lpRect
戻り値の各辺を縮小するユニットの数を含む RECT 構造体または CRect オブジェクトを指します。

戻り値

パラメーターで指定したユニットの数だけ CRect を移動または縮小した結果として得られる CRect

解説

パラメーターの xy (または cxcy) の各パラメーターが CRect の位置から減算されます。

3 番目のオーバーロードは、パラメーターの各メンバーで指定したユニットの数だけ縮小された CRect に等しい、新しい CRect を返します。 このオーバーロードは、SubtractRect ではなく DeflateRect と同様に機能します。

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect   rect2;

rect2 = rect1 - pt;
CRect   rectResult(65, 170, 165, 270);
ASSERT(rect2 == rectResult);

CRect::operator &

CRectrect2 の積集合である CRect を返します。

CRect operator&(const RECT& rect2) const throw();

パラメーター

rect2
RECT または CRect が含まれています。

戻り値

CRectrect2 の積集合である CRect

解説

積集合は、両方の四角形に含まれている最大の四角形です。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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);

CRect::operator |

CRectrect2 の和集合である CRect を返します。

CRect operator|(const RECT&
rect2) const throw();

パラメーター

rect2
RECT または CRect が含まれています。

戻り値

CRectrect2 の和集合である CRect

解説

和集合は、両方の四角形を含む最小の四角形です。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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);

CRect::PtInRect

指定した点が CRect の内側にあるかどうかを判断します。

BOOL PtInRect(POINT point) const throw();

パラメーター

point
POINT 構造体または CPoint オブジェクトが含まれています。

戻り値

点が CRect の内側にある場合は 0 以外。それ以外の場合は 0。

解説

点が左辺上か上辺上にあるか、または 4 つのすべての辺の内側にある場合、点は CRect の内側にあります。 右辺または底辺は CRect の外側にあります。

Note

四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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));

CRect::SetRect

CRect のディメンションを、指定した座標に設定します。

void SetRect(int x1, int y1, int x2, int y2) throw();

パラメーター

x1
左上隅の X 座標を指定します。

y1
左上隅の Y 座標を指定します。

x2
右下隅の X 座標を指定します。

y2
右下隅の Y 座標を指定します。

CRect rect;
rect.SetRect(256, 256, 512, 512);
ASSERT(rect == CRect(256, 256, 512, 512));

CRect::SetRectEmpty

すべての座標を 0 に設定して、CRect を null 四角形にします。

void SetRectEmpty() throw();

CRect rect;
rect.SetRectEmpty();

// rect is now (0, 0, 0, 0)
ASSERT(rect.IsRectEmpty());

CRect::SIZE

戻り値の cx メンバーと cy メンバーには、CRect の高さと幅が含まれています。

CSize Size() const throw();

戻り値

CRect のサイズを含む CSize オブジェクト。

解説

高さと幅のどちらかが負の値になる可能性があります。

Note

四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

CRect rect(10, 10, 50, 50);
CSize sz = rect.Size();
ASSERT(sz.cx == 40 && sz.cy == 40);

CRect::SubtractRect

CRect のディメンションを、lpRectSrc1 から lpRectSrc2 を減算した値に等しくなるようにします。

BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();

パラメーター

lpRectSrc1
四角形を減算する RECT 構造体または CRect オブジェクトを指します。

lpRectSrc2
lpRectSrc1 パラメーターが指す四角形から減算される RECT 構造体または CRect オブジェクトを指します。

戻り値

正常終了した場合は 0 以外を返します。それ以外の場合は 0 を返します。

解説

減算は、lpRectScr1lpRectScr2 の積集合に含まれない lpRectScr1 内のすべての点を含む最小の四角形です。

lpRectSrc2 で指定した四角形が、lpRectSrc1 で指定した四角形と、X 方向または Y 方向の少なくとも 1 つで完全には重なっていない場合、lpRectSrc1 で指定した四角形は変更されません。

たとえば、lpRectSrc1 が (10,10, 100,100)、lpRectSrc2 が (50,50, 150,150) の場合、関数が返されたときに、lpRectSrc1 が指す四角形は変更されません。 ただし、lpRectSrc1 が (10,10, 100,100)、lpRectSrc2 が (50,10, 150,150) の場合、関数が返されたときに、lpRectSrc1 が指す四角形には座標 (10,10, 50,100) が含まれます。

SubtractRect は、演算子 -演算子 -= と同じではありません。 これらの演算子によって SubtractRect が呼び出されることはありません。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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);

CRect::TopLeft

座標は、CRect に含まれている CPoint オブジェクトへの参照として返されます。

CPoint& TopLeft() throw();
const CPoint& TopLeft() const throw();

戻り値

四角形の左上隅の X 座標。

解説

この関数を使用すると、四角形の左上隅を取得または設定できます。 代入演算子の左側にあるこの関数を使用して、この隅を設定します。

CRect::CenterPoint の例を参照してください。

CRect::UnionRect

CRect のディメンションが、2 つのソースの四角形の和集合に等しくなるようにします。

BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

パラメーター

lpRect1
ソースの四角形を含む RECT または CRect を指します。

lpRect2
ソースの四角形を含む RECT または CRect を指します。

戻り値

和集合が空でない場合は 0 以外。和集合が空の場合は 0。

解説

和集合は、両方のソースの四角形を含む最小の四角形です。

Windows では、空の四角形、つまり高さや幅のない四角形のディメンションが無視されます。

Note

両方の四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

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);

CRect::Width

右の値から左の値を減算することで、CRect の幅を計算します。

int Width() const throw();

戻り値

CRect の幅。

解説

幅は負の値である可能性があります。

Note

四角形が正規化されている必要があります。そうでない場合、この関数は失敗する可能性があります。 この関数を呼び出す前に、NormalizeRect を呼び出して四角形を正規化できます。

CRect rect(20, 30, 80, 70);
int nWid = rect.Width();
// nWid is now 60
ASSERT(nWid == 60);

関連項目

CPoint クラス
CSize クラス
RECT