CRect Klasa

Podobnie jak struktura systemu Windows RECT .

Składnia

class CRect : public tagRECT

Elementy członkowskie

Konstruktory publiczne

Nazwa/nazwisko	opis
CRect::CRect	CRect Tworzy obiekt.

Metody publiczne

Nazwa/nazwisko	opis
CRect::BottomRight	Zwraca prawy dolny punkt .CRect
CRect::CenterPoint	Zwraca punkt środkowy .CRect
CRect::CopyRect	Kopiuje wymiary prostokąta źródłowego do CRect.
CRect::DeflateRect	Zmniejsza szerokość i wysokość CRectobiektu .
CRect::EqualRect	Określa, czy CRect jest równe danym prostokątowi.
CRect::Height	Oblicza wysokość CRectelementu .
CRect::InflateRect	Zwiększa szerokość i wysokość CRectobiektu .
CRect::IntersectRect	Ustawia CRect wartość równą przecięciu dwóch prostokątów.
CRect::IsRectEmpty	Określa, czy CRect jest pusty. CRect wartość jest pusta, jeśli szerokość i/lub wysokość to 0.
CRect::IsRectNull	Określa, czy topzmienne składowe , bottom, lefti right są równe 0.
CRect::MoveToX	Przenosi CRect się do określonej współrzędnej x.
CRect::MoveToXY	Przenosi CRect się do określonych współrzędnych x-i y.
CRect::MoveToY	Przenosi CRect się do określonej współrzędnej y.
CRect::NormalizeRect	Standaryzacja wysokości i szerokości CRect.
CRect::OffsetRect	Przenosi CRect się według określonych przesunięć.
CRect::PtInRect	Określa, czy określony punkt znajduje się w obiekcie CRect.
CRect::SetRect	Ustawia wymiary .CRect
CRect::SetRectEmpty	Ustawia CRect pusty prostokąt (wszystkie współrzędne równe 0).
CRect::Size	Oblicza rozmiar CRect.
CRect::SubtractRect	Odejmuje jeden prostokąt z innego.
CRect::TopLeft	Zwraca lewy górny punkt .CRect
CRect::UnionRect	Ustawia CRect wartość równą unii dwóch prostokątów.
CRect::Width	Oblicza szerokość elementu CRect.

Operatory publiczne

Nazwa/nazwisko	opis
CRect::operator -	Odejmuje podane przesunięcia z CRect lub deflates CRect i zwraca wynikowy CRect.
CRect::operator LPCRECT	Konwertuje element na CRect .LPCRECT
CRect::operator LPRECT	Konwertuje element na CRect .LPRECT
CRect::operator !=	Określa, czy CRect nie jest równe prostokątowi.
CRect::operator &	Tworzy przecięcie CRect i prostokąt i zwraca wynikowy CRectelement .
CRect::operator &=	Ustawia CRect wartość równą przecięciu CRect i prostokątowi.
CRect::operator |	Tworzy unii CRect i prostokąta i zwraca wynikowy CRectelement .
CRect::operator |=	Ustawia CRect wartość równą unii CRect i prostokąta.
CRect::operator +	Dodaje podane przesunięcia do CRect lub zawyżania CRect i zwraca wynikowy CRect.
CRect::operator +=	Dodaje określone przesunięcia do CRect lub zawyża .CRect
CRect::operator =	Kopiuje wymiary prostokąta do CRect.
CRect::operator -=	Odejmuje określone przesunięcia z CRect lub deflates CRect.
CRect::operator ==	Określa, czy CRect jest równe prostokątowi.

Uwagi

CRect Zawiera również funkcje składowe do manipulowania CRect obiektami i strukturami systemu Windows RECT .

CRect Obiekt można przekazać jako parametr funkcji wszędzie tam, LPCRECTgdzie RECT można przekazać strukturę lubLPRECT.

Uwaga

Ta klasa pochodzi ze tagRECT struktury. (Nazwa tagRECT jest mniej często używaną nazwą struktury RECT ). Oznacza to, że składowe danych (left, top, righti bottom) RECT struktury są dostępnymi elementami członkowskimi CRectdanych .

Element CRect zawiera zmienne składowe, które definiują lewy górny i dolny prawy punkt prostokąta.

Podczas określania CRectelementu należy zachować ostrożność, aby ją skonstruować, tak aby była znormalizowana — innymi słowy, wartość współrzędnych po lewej stronie jest mniejsza niż prawa, a górna wartość jest mniejsza niż dolna. Na przykład w lewym górnym rogu (10 10 10) i prawym dolnym rogu (20 20 20) zdefiniowano znormalizowany prostokąt, ale lewy górny (20 20 20) i prawy dolny (10 10 10) definiuje nienormalizowany prostokąt. Jeśli prostokąt nie jest znormalizowany, wiele CRect funkcji składowych może zwracać nieprawidłowe wyniki. (Zobacz CRect::NormalizeRect listę tych funkcji). Przed wywołaniem funkcji wymagającej znormalizowanych prostokątów można znormalizować nienormalizowane prostokąty, wywołując NormalizeRect funkcję.

Należy zachować ostrożność podczas manipulowania CRect elementami za pomocą funkcji składowych CDC::DPtoLP i CDC::LPtoDP . Jeśli tryb mapowania kontekstu wyświetlania jest taki, że zakres y jest ujemny, jak w MM_LOENGLISHpliku , CDC::DPtoLP zmieni wartość CRect tak, aby jego górna część jest większa niż dolna. Funkcje takie jak Height i Size zwracają wartości ujemne dla wysokości przekształconego CRectobiektu , a prostokąt będzie nie znormalizowany.

W przypadku używania przeciążonych CRect operatorów pierwszy operand musi być argumentem CRect; drugi może być strukturą RECT lub obiektem CRect .

Hierarchia dziedziczenia

tagRECT

CRect

Wymagania

Nagłówek: atltypes.h

CRect::BottomRight

Współrzędne są zwracane jako odwołanie do CPoint obiektu, który znajduje się w CRectobiekcie .

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

Wartość zwracana

Współrzędne prawego dolnego rogu prostokąta.

Uwagi

Tej funkcji można użyć do pobrania lub ustawienia prawego dolnego rogu prostokąta. Ustaw narożnik przy użyciu tej funkcji po lewej stronie operatora przypisania.

Przykład

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

Oblicza punkt środkowy CRect , dodając wartości lewe i prawe oraz dzieląc przez dwa, a następnie dodając wartości górne i dolne oraz dzieląc przez dwa.

CPoint CenterPoint() const throw();

Wartość zwracana

CPoint Obiekt, który jest centralnym punktem CRect.

Przykład

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

Kopiuje lpSrcRect prostokąt do CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parametry

lpSrcRect
RECT Wskazuje strukturę lub CRect obiekt, który ma zostać skopiowany.

Przykład

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 Tworzy obiekt.

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

Parametry

l
Określa lewą pozycję CRect.

t
Określa górną część obiektu CRect.

r
Określa prawą pozycję .CRect

b
Określa dół .CRect

srcRect
Odwołuje się do RECT struktury ze współrzędnymi dla CRectelementu .

lpSrcRect
RECT Wskazuje strukturę ze współrzędnymi dla CRectelementu .

point
Określa punkt początkowy prostokąta, który ma zostać skonstruowany. Odpowiada lewemu górnemu rogu.

size
Określa przemieszczenie z lewego górnego rogu do prawego dolnego rogu prostokąta, który ma zostać skonstruowany.

topLeft
Określa lewą górną pozycję .CRect

bottomRight
Określa prawą dolną pozycję .CRect

Uwagi

Jeśli nie podano żadnych argumentów, leftelementy członkowskie , top, righti bottom są ustawione na 0.

Konstruktory () i CRect(LPCRECT) wykonują operację CopyRect.const RECT&CRect Inne konstruktory inicjują zmienne składowe obiektu bezpośrednio.

Przykład

// 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 deflates, przesuwając boki CRect w kierunku środka.

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

Parametry

x
Określa liczbę jednostek do deflacji lewej i prawej strony .CRect

y
Określa liczbę jednostek do deflacji górnej i dolnej części CRect.

size
A SIZE lub CSize , który określa liczbę jednostek do deflacji CRect. Wartość cx określa liczbę jednostek do deflacji po lewej i prawej stronie, a cy wartość określa liczbę jednostek do deflacji górnej i dolnej.

lpRect
RECT Wskazuje strukturę lub CRect określa liczbę jednostek do deflacji po każdej stronie.

l
Określa liczbę jednostek do deflacji lewej strony .CRect

t
Określa liczbę jednostek do deflacji górnej części CRect.

r
Określa liczbę jednostek do deflacji po prawej stronie CRect.

b
Określa liczbę jednostek do deflacji dolnej części CRect.

Uwagi

W tym DeflateRect celu dodaje jednostki do lewej i górnej i odejmuje jednostki z prawej i dolnej części. Parametry DeflateRect są wartościami ze znakiem; wartości dodatnie deflate CRect i wartości ujemne zawyżają je.

Dwa pierwsze przeciążenia deflatują obie pary przeciwnych stronCRect, tak aby jej całkowita szerokość została zmniejszona o dwa razy x (lub ), a łączna wysokość jest zmniejszana o dwa razy y (lub cxcy). Pozostałe dwa przeciążenia deflują każdą stronę CRect niezależnie od pozostałych.

Przykład

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

Określa, czy CRect jest równe danym prostokątowi.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parametry

lpRect
RECT Wskazuje strukturę lub CRect obiekt zawierający współrzędne lewego górnego i prawego dolnego rogu prostokąta.

Wartość zwracana

Niezerowe, jeśli dwa prostokąty mają te same wartości od góry, lewej, dolnej i prawej; w przeciwnym razie 0.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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

Oblicza wysokość przez CRect odjęcie najwyższej wartości od wartości dolnej.

int Height() const throw();

Wartość zwracana

Wysokość CRectelementu .

Uwagi

Wynikowa wartość może być ujemna.

Uwaga

Prostokąt musi być znormalizowany lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokąta.

Przykład

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

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

CRect::InflateRect

InflateRect zawyża CRect , przesuwając boki z dala od środka.

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

Parametry

x
Określa liczbę jednostek, które mają zawyżać lewą i prawą stronę obiektu CRect.

y
Określa liczbę jednostek, które mają zawyżać górną i dolną część .CRect

size
A SIZE lub CSize określa liczbę jednostek, które mają być zawyżone CRect. Wartość cx określa liczbę jednostek, które mają zawyżać lewe i prawe strony, a cy wartość określa liczbę jednostek, które mają zawyżać górny i dolny.

lpRect
RECT Wskazuje strukturę lub CRect określa liczbę jednostek, które mają być zawyżone po każdej stronie.

l
Określa liczbę jednostek, które mają zawyżać lewą stronę .CRect

t
Określa liczbę jednostek, które mają zawyżać górną część .CRect

r
Określa liczbę jednostek, które mają zawyżać prawą stronę .CRect

b
Określa liczbę jednostek, które mają zawyżać dolną część .CRect

Uwagi

W tym InflateRect celu odejmuje jednostki od lewej i górnej i dodaje jednostki do prawej i dolnej części. Parametry InflateRect są wartościami ze znakiem; wartości dodatnie zawyżają i wartości ujemne CRect .

Dwa pierwsze przeciążenia zawyżają obie pary przeciwnych stronCRect, dzięki czemu jej całkowita szerokość jest zwiększana o dwa razy x (lub ), a łączna wysokość jest zwiększana o dwa razy y (lub cxcy). Pozostałe dwa przeciążenia zawyżają każdą stronę CRect niezależnie od pozostałych.

Przykład

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

Tworzy wartość równą przecięciu CRect dwóch istniejących prostokątów.

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

Parametry

lpRect1
RECT Wskazuje strukturę lub CRect obiekt, który zawiera prostokąt źródłowy.

lpRect2
RECT Wskazuje strukturę lub CRect obiekt, który zawiera prostokąt źródłowy.

Wartość zwracana

Niezerowe, jeśli skrzyżowanie nie jest puste; 0, jeśli skrzyżowanie jest puste.

Uwagi

Przecięcie jest największym prostokątem znajdującym się w obu istniejących prostokątach.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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

Określa, czy CRect jest pusty.

BOOL IsRectEmpty() const throw();

Wartość zwracana

Wartość niezerowa, jeśli CRect jest pusta; 0, jeśli CRect nie jest pusta.

Uwagi

Prostokąt jest pusty, jeśli szerokość i/lub wysokość są 0 lub ujemne. Różni się od IsRectNullelementu , który określa, czy wszystkie współrzędne prostokąta mają wartość zero.

Uwaga

Prostokąt musi być znormalizowany lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokąta.

Przykład

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

Określa, czy górne, lewe, dolne i prawe wartości CRect są równe 0.

BOOL IsRectNull() const throw();

Wartość zwracana

Niezerowe, jeśli CRectwartości górne, lewe, dolne i prawe są równe 0; w przeciwnym razie 0.

Uwagi

Różni się od IsRectEmptyelementu , który określa, czy prostokąt jest pusty.

Przykład

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

Wywołaj tę funkcję, aby przenieść prostokąt do bezwzględnej współrzędnej x określonej przez x.

void MoveToX(int x) throw();

Parametry

x
Bezwzględna współrzędna x dla lewego górnego rogu prostokąta.

Przykład

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

Wywołaj tę funkcję, aby przenieść prostokąt do określonych współrzędnych bezwzględnych x-i y.

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

Parametry

x
Bezwzględna współrzędna x dla lewego górnego rogu prostokąta.

y
Bezwzględna współrzędna y dla lewego górnego rogu prostokąta.

point
Struktura POINT określająca bezwzględny lewy górny róg prostokąta.

Przykład

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

Wywołaj tę funkcję, aby przenieść prostokąt do bezwzględnej współrzędnej y określonej przez y.

void MoveToY(int y) throw();

Parametry

y
Bezwzględna współrzędna y dla lewego górnego rogu prostokąta.

Przykład

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

Normalizuje tak CRect , aby wysokość i szerokość są dodatnie.

void NormalizeRect() throw();

Uwagi

Prostokąt jest znormalizowany dla pozycjonowania czwartej ćwiartki, którego system Windows zwykle używa do współrzędnych. NormalizeRect porównuje górne i dolne wartości i zamienia je, jeśli górna część jest większa niż dolna. Podobnie zamienia wartości po lewej i prawej, jeśli lewa jest większa niż po prawej stronie. Ta funkcja jest przydatna podczas pracy z różnymi trybami mapowania i odwróconymi prostokątami.

Uwaga

Następujące CRect funkcje składowe wymagają znormalizowanych prostokątów w celu prawidłowego działania: Height, , Sizeoperator |=operator ==operator !=SubtractRectoperator |operator &WidthPtInRectoperator &=IsRectEmptyEqualRectUnionRectIntersectRecti .

Przykład

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

CRect::OffsetRect

Przenosi CRect się według określonych przesunięć.

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

Parametry

x
Określa ilość do przeniesienia w lewo lub w prawo. Musi to być ujemne, aby przejść w lewo.

y
Określa ilość do przeniesienia w górę lub w dół. Musi to być ujemne, aby przejść w górę.

point
POINT Zawiera strukturę lub CPoint obiekt określający oba wymiary do przeniesienia.

size
SIZE Zawiera strukturę lub CSize obiekt określający oba wymiary do przeniesienia.

Uwagi

Przenosi CRectx jednostki wzdłuż osi x i y jednostek wzdłuż osi y. Parametry x i y są wartościami ze znakiem, więc CRect można je przenosić w lewo lub w prawo i w górę lub w dół.

Przykład

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 LPCRECTKonwertuje element na CRect .LPCRECT

operator LPCRECT() const throw();

Uwagi

Jeśli używasz tej funkcji, nie potrzebujesz operatora address-of (&). Ten operator będzie automatycznie używany podczas przekazywania CRect obiektu do funkcji, która oczekuje LPCRECTobiektu .

CRect::operator LPRECT

Konwertuje element na CRect .LPRECT

operator LPRECT() throw();

Uwagi

Jeśli używasz tej funkcji, nie potrzebujesz operatora address-of (&). Ten operator będzie automatycznie używany podczas przekazywania CRect obiektu do funkcji, która oczekuje LPRECTobiektu .

Przykład

Zobacz przykład dla elementu CRect::operator LPCRECT.

CRect::operator =

srcRect Przypisuje do CRect.

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

Parametry

srcRect
Odwołuje się do prostokąta źródłowego. Może być elementem RECT lub CRect.

Przykład

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

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

CRect::operator ==

Określa, czy rect jest równe CRect , porównując współrzędne ich lewy górny i dolny prawy róg.

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

Parametry

rect
Odwołuje się do prostokąta źródłowego. Może być elementem RECT lub CRect.

Wartość zwracana

Niezerowe, jeśli równe; w przeciwnym razie 0.

Uwagi

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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 !=

Określa, czy rect nie jest równe CRect , porównując współrzędne ich lewy górny i dolny prawy róg.

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

Parametry

rect
Odwołuje się do prostokąta źródłowego. Może być elementem RECT lub CRect.

Wartość zwracana

Wartość niezerowa, jeśli nie jest równa; w przeciwnym razie 0.

Uwagi

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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 +=

Pierwsze dwa przeciążenia są przenoszone CRect przez określone przesunięcia.

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

Parametry

point
Struktura POINT lub CPoint obiekt określający liczbę jednostek do przeniesienia prostokąta.

size
Struktura SIZE lub CSize obiekt określający liczbę jednostek do przeniesienia prostokąta.

lpRect
RECT Wskazuje strukturę lub CRect obiekt, który zawiera liczbę jednostek, aby zawyżać każdą stronę obiektu CRect.

Uwagi

Wartości parametrów x i y (lub cx i cy) są dodawane do CRectelementu .

Trzecie przeciążenie zawyża CRect liczbę jednostek określonych w każdym elemencie członkowskim parametru.

Przykład

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

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

CRect::operator -=

Pierwsze dwa przeciążenia są przenoszone CRect przez określone przesunięcia.

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

Parametry

point
Struktura POINT lub CPoint obiekt określający liczbę jednostek do przeniesienia prostokąta.

size
Struktura SIZE lub CSize obiekt określający liczbę jednostek do przeniesienia prostokąta.

lpRect
RECT Wskazuje strukturę lub CRect obiekt, który zawiera liczbę jednostek do deflacji po każdej stronie CRect.

Uwagi

Wartości parametrów x i y (lub cx i cy) są odejmowane z CRect.

Trzecie przeciążenie jest deflate CRect przez liczbę jednostek określonych w każdym elemencie członkowskim parametru. Należy pamiętać, że to przeciążenie funkcji, takich jak DeflateRect.

Przykład

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

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

CRect::operator &=

Ustawia CRect wartość równą przecięciu wartości CRect i rect.

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

Parametry

rect
Zawiera element RECT lub CRect.

Uwagi

Przecięcie jest największym prostokątem, który znajduje się w obu prostokątach.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

Zobacz przykład dla elementu CRect::IntersectRect.

CRect::operator |=

Ustawia CRect wartość równą unii wartości CRect i rect.

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

Parametry

rect
Zawiera element CRect lub RECT.

Uwagi

Związek jest najmniejszym prostokątem zawierającym oba prostokąty źródłowe.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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 +

Pierwsze dwa przeciążenia zwracają CRect obiekt, który jest równy CRect przesiedleniu przez określone przesunięcia.

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

Parametry

point
Struktura POINT lub CPoint obiekt określający liczbę jednostek do przeniesienia wartości zwracanej.

size
Struktura SIZE lub CSize obiekt określający liczbę jednostek do przeniesienia wartości zwracanej.

lpRect
RECT Wskazuje strukturę lub CRect obiekt, który zawiera liczbę jednostek, aby zawyżać każdą stronę wartości zwracanej.

Wartość zwracana

Wynik CRect przenoszenia lub zawyżania CRect przez liczbę jednostek określonych w parametrze.

Uwagi

Parametry parametrów x i y (lub cx i cy) są dodawane do CRectpozycji .s.

Trzecie przeciążenie zwraca nowy CRect , który jest równy CRect zawyżonej liczbie jednostek określonych w każdym elemencie członkowskim parametru.

Przykład

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 -

Pierwsze dwa przeciążenia zwracają CRect obiekt, który jest równy CRect przesiedleniu przez określone przesunięcia.

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

Parametry

point
Struktura POINT lub CPoint obiekt określający liczbę jednostek do przeniesienia wartości zwracanej.

size
Struktura SIZE lub CSize obiekt określający liczbę jednostek do przeniesienia wartości zwracanej.

lpRect
RECT Wskazuje strukturę lub CRect obiekt, który zawiera liczbę jednostek do deflacji każdej strony wartości zwracanej.

Wartość zwracana

Wynik CRect przenoszenia lub deflatingu CRect przez liczbę jednostek określonych w parametrze.

Uwagi

Parametry parametrów x i y (lub cx i cy) są odejmowane od CRectpozycji .

Trzecie przeciążenie zwraca nowy CRect , który jest równy CRect deflated przez liczbę jednostek określonych w każdym elemencie członkowskim parametru. Należy pamiętać, że to przeciążenie funkcji, takich jak DeflateRect, a nie SubtractRect.

Przykład

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 &

Zwraca element, który jest przecięciem CRect CRect i rect2.

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

Parametry

rect2
Zawiera element RECT lub CRect.

Wartość zwracana

Element CRect , który jest przecięciem i CRect rect2.

Uwagi

Przecięcie jest największym prostokątem, który znajduje się w obu prostokątach.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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 |

Zwraca wartość typu CRect , która jest unią wartości CRect i rect2.

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

Parametry

rect2
Zawiera element RECT lub CRect.

Wartość zwracana

A CRect to jest związek i CRect rect2.

Uwagi

Związek jest najmniejszym prostokątem zawierającym oba prostokąty.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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

Określa, czy określony punkt znajduje się w obiekcie CRect.

BOOL PtInRect(POINT point) const throw();

Parametry

point
POINT Zawiera strukturę lub CPoint obiekt.

Wartość zwracana

Nonzero, jeśli punkt leży w obrębie CRect; w przeciwnym razie 0.

Uwagi

Punkt znajduje się wewnątrz CRect , jeśli leży po lewej lub górnej stronie lub znajduje się po wszystkich czterech stronach. Punkt po prawej lub dolnej stronie znajduje się na zewnątrz CRect.

Uwaga

Prostokąt musi być znormalizowany lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokąta.

Przykład

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

Ustawia wymiary CRect określone współrzędnych.

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

Parametry

x1
Określa współrzędną x lewego górnego rogu.

y1
Określa współrzędną y lewego górnego rogu.

x2
Określa współrzędną x prawego dolnego rogu.

y2
Określa współrzędną y prawego dolnego rogu.

Przykład

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

CRect::SetRectEmpty

Tworzy CRect prostokąt o wartości null przez ustawienie wszystkich współrzędnych na zero.

void SetRectEmpty() throw();

Przykład

CRect rect;
rect.SetRectEmpty();

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

CRect::SIZE

Elementy cx i cy wartości zwracanej zawierają wysokość i szerokość CRectelementu .

CSize Size() const throw();

Wartość zwracana

CSize Obiekt, który zawiera rozmiar CRect.

Uwagi

Wysokość lub szerokość mogą być ujemne.

Uwaga

Prostokąt musi być znormalizowany lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokąta.

Przykład

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

CRect::SubtractRect

Sprawia, że wymiary CRect równe odejmowi lpRectSrc2 wartości z .lpRectSrc1

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

Parametry

lpRectSrc1
RECT Wskazuje strukturę lub CRect obiekt, z którego ma zostać odjęcie prostokąta.

lpRectSrc2
RECT Wskazuje strukturę lub CRect obiekt, który ma zostać odjęty od prostokąta wskazywanego lpRectSrc1 przez parametr .

Wartość zwracana

Różne od zera, jeśli funkcja zakończyła się pomyślnie; w przeciwnym razie 0.

Uwagi

Odejmowanie jest najmniejszym prostokątem zawierającym wszystkie punkty, lpRectScr1 które nie znajdują się na przecięciu lpRectScr1 elementów i lpRectScr2.

Prostokąt określony przez lpRectSrc1 będzie niezmieniony, jeśli prostokąt określony przez lpRectSrc2 nie całkowicie nakłada się na prostokąt określony przez lpRectSrc1 co najmniej jeden z x- lub y-kierunkowych.

Na przykład w przypadku lpRectSrc1 wartości (10 10 10, 100 100) i lpRectSrc2 (50 50 50, 150 150), prostokąt wskazywany przez lpRectSrc1 będzie niezmieniony, gdy funkcja zwróci wartość. Gdyby lpRectSrc1 (10 10 10, 100 100) i lpRectSrc2 były (50,10, 150 150), jednak prostokąt wskazywany przez lpRectSrc1 będzie zawierał współrzędne (10 10,10, 50 100), gdy funkcja zwróciła.

SubtractRect nie jest taki sam jak operator - ani operator -=. Żaden z tych operatorów nigdy nie wywołuje elementu SubtractRect.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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

Współrzędne są zwracane jako odwołanie do CPoint obiektu, który znajduje się w CRectobiekcie .

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

Wartość zwracana

Współrzędne lewego górnego rogu prostokąta.

Uwagi

Za pomocą tej funkcji można uzyskać lub ustawić lewy górny róg prostokąta. Ustaw narożnik przy użyciu tej funkcji po lewej stronie operatora przypisania.

Przykład

Zobacz przykład dla elementu CRect::CenterPoint.

CRect::UnionRect

Sprawia, że wymiary CRect równe unii dwóch prostokątów źródłowych.

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

Parametry

lpRect1
Wskazuje element RECT lub CRect , który zawiera prostokąt źródłowy.

lpRect2
Wskazuje element RECT lub CRect , który zawiera prostokąt źródłowy.

Wartość zwracana

Nonzero, jeśli unia nie jest pusta; 0, jeśli unia jest pusta.

Uwagi

Związek jest najmniejszym prostokątem zawierającym oba prostokąty źródłowe.

System Windows ignoruje wymiary pustego prostokąta; oznacza to, prostokąt, który nie ma wysokości lub nie ma szerokości.

Uwaga

Oba prostokąty muszą być znormalizowane lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokątów.

Przykład

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

Oblicza szerokość, CRect odejmując lewą wartość z prawej wartości.

int Width() const throw();

Wartość zwracana

Szerokość elementu CRect.

Uwagi

Szerokość może być ujemna.

Uwaga

Prostokąt musi być znormalizowany lub ta funkcja może zakończyć się niepowodzeniem. Przed wywołaniem tej funkcji można wywołać NormalizeRect metodę normalizacji prostokąta.

Przykład

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

Zobacz też

CPoint Klasa
CSize Klasa
RECT