`CRect` Třída

Článek
07/05/2024

Podobá se struktuře Windows RECT .

Syntaxe

class CRect : public tagRECT

Členové

Veřejné konstruktory

Název	Popis
`CRect::CRect`	`CRect` Vytvoří objekt.

Veřejné metody

Název	Popis
`CRect::BottomRight`	Vrátí pravý dolní bod `CRect`.
`CRect::CenterPoint`	Vrátí středový `CRect`bod .
`CRect::CopyRect`	Zkopíruje rozměry zdrojového obdélníku do `CRect`.
`CRect::DeflateRect`	Zmenší šířku a výšku `CRect`.
`CRect::EqualRect`	Určuje, zda `CRect` se rovná danému obdélníku.
`CRect::Height`	Vypočítá výšku `CRect`.
`CRect::InflateRect`	Zvětší šířku a výšku `CRect`.
`CRect::IntersectRect`	Nastaví `CRect` rovnající se průsečíku dvou obdélníků.
`CRect::IsRectEmpty`	Určuje, zda `CRect` je prázdná. `CRect` je prázdná, pokud je šířka a/nebo výška 0.
`CRect::IsRectNull`	Určuje, `left`zda `top`jsou všechny proměnné , `bottom`a `right` členské proměnné rovny 0.
`CRect::MoveToX`	Přesune `CRect` se na zadanou souřadnici x.
`CRect::MoveToXY`	Přesune `CRect` se na zadané souřadnice x a y.
`CRect::MoveToY`	Přesune `CRect` se na zadanou souřadnici y.
`CRect::NormalizeRect`	Standardizuje výšku a šířku `CRect`.
`CRect::OffsetRect`	Přesune `CRect` podle zadaných posunů.
`CRect::PtInRect`	Určuje, zda zadaný bod leží v rámci `CRect`.
`CRect::SetRect`	Nastaví rozměry `CRect`.
`CRect::SetRectEmpty`	Nastaví `CRect` na prázdný obdélník (všechny souřadnice se rovnají 0).
`CRect::Size`	Vypočítá velikost `CRect`.
`CRect::SubtractRect`	Odečte jeden obdélník od druhého.
`CRect::TopLeft`	Vrátí levý horní bod `CRect`.
`CRect::UnionRect`	Nastaví `CRect` stejnou sjednocení dvou obdélníků.
`CRect::Width`	Vypočítá šířku .`CRect`

Veřejné operátory

Název	Popis
`CRect::operator -`	Odečte dané posuny od `CRect` nebo odfoukne `CRect` a vrátí výsledek `CRect`.
`CRect::operator LPCRECT`	Převede na `CRect` .`LPCRECT`
`CRect::operator LPRECT`	Převede na `CRect` .`LPRECT`
`CRect::operator !=`	Určuje, zda `CRect` se nerovná obdélníku.
`CRect::operator &`	Vytvoří průsečík `CRect` a obdélník a vrátí výsledek `CRect`.
`CRect::operator &=`	Nastaví `CRect` rovnu průsečíku `CRect` a obdélníku.
`CRect::operator \|`	Vytvoří sjednocení `CRect` obdélníku a vrátí výslednou `CRect`hodnotu .
`CRect::operator \|=`	Nastaví `CRect` stejnou sjednocení `CRect` a obdélník.
`CRect::operator +`	Přidá dané posuny do `CRect` nebo nafouknutí `CRect` a vrátí výsledek `CRect`.
`CRect::operator +=`	Přidá zadané posuny do `CRect` nebo nafouknutí `CRect`.
`CRect::operator =`	Zkopíruje rozměry obdélníku do `CRect`.
`CRect::operator -=`	Odečte zadané posuny od `CRect` nebo odfoukne `CRect`.
`CRect::operator ==`	Určuje, zda `CRect` je rovno obdélníku.

Poznámky

CRect obsahuje také členské funkce pro manipulaci s CRect objekty a strukturami Systému Windows RECT .

Objekt CRect lze předat jako parametr funkce všude, kde RECT je struktura , LPCRECTnebo LPRECT lze předat.

Poznámka:

Tato třída je odvozena ze tagRECT struktury. (Název tagRECT je méně často používaný název struktury RECT .) To znamená, že datové členy (left, top, righta bottom) RECT struktury jsou přístupné datové členy CRect.

A CRect obsahuje členské proměnné, které definují levé horní a pravé dolní body obdélníku.

Při zadávání CRectmusíte být opatrní, abyste ho vytvořili tak, aby byl normalizován – jinými slovy, že hodnota levé souřadnice je menší než vpravo a horní je menší než dolní. Například levý horní okraj (10 10) a pravý dolní okraj (20 20 20) definuje normalizovaný obdélník, ale vlevo nahoře od (20 20 20) a vpravo dole (10 10 10) definuje nenormalizovaný obdélník. Pokud obdélník není normalizován, může mnoho CRect členských funkcí vrátit nesprávné výsledky. (Podívejte se CRect::NormalizeRect na seznam těchto funkcí.) Před voláním funkce, která vyžaduje normalizované obdélníky, můžete normalizovat nenormalizované obdélníky voláním NormalizeRect funkce.

Při manipulaci CRect s funkcemi CDC::DPtoLP a CDC::LPtoDP členské funkce buďte opatrní. Pokud je režim mapování kontextu zobrazení takový, že rozsah y je záporný, stejně jako v MM_LOENGLISH, pak CDC::DPtoLP transformuje CRect tak, aby jeho horní část byla větší než dole. Funkce jako Height a Size pak vrátí záporné hodnoty pro výšku transformovaného CRectobjektu a obdélník nebude normalizován.

Při použití přetížených CRect operátorů musí být prvním operandem CRect; druhý může být RECT struktura nebo CRect objekt.

Hierarchie dědičnosti

tagRECT

CRect

Požadavky

Záhlaví: atltypes.h

`CRect::BottomRight`

Souřadnice jsou vráceny jako odkaz na CPoint objekt, který je obsažen v CRect.

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

Návratová hodnota

Souřadnice pravého dolního rohu obdélníku

Poznámky

Tuto funkci můžete použít k získání nebo nastavení pravého dolního rohu obdélníku. Na levé straně operátoru přiřazení nastavte roh pomocí této funkce.

Příklad

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

Vypočítá střed CRect tím, že přidá hodnoty zleva a doprava a vydělí dvěma a přidá nejvyšší a nejnižší hodnoty a vydělí dvěma.

CPoint CenterPoint() const throw();

Návratová hodnota

Objekt CPoint , který je středem CRect.

Příklad

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

Zkopíruje lpSrcRect obdélník do CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parametry

lpSrcRect
Odkazuje na RECT strukturu nebo CRect objekt, který se má zkopírovat.

Příklad

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 Vytvoří objekt.

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
Určuje levou pozici CRect.

t
Určuje horní část .CRect

r
Určuje správnou pozici CRect.

b
Určuje dolní část .CRect

srcRect
Odkazuje na RECT strukturu se souřadnicemi pro CRect.

lpSrcRect
Odkazuje na RECT strukturu se souřadnicemi pro CRect.

point
Určuje počáteční bod pro vytvoření obdélníku. Odpovídá levému hornímu rohu.

size
Určuje posunutí z levého horního rohu do pravého dolního rohu obdélníku, který se má vytvořit.

topLeft
Určuje levou horní pozici CRect.

bottomRight
Určuje pravou dolní pozici CRect.

Poznámky

Pokud nejsou zadány žádné argumenty, lefttoprighta bottom členy jsou nastaveny na 0.

Konstruktory CRect(const RECT&) a CRect(LPCRECT) provádějí .CopyRect Ostatní konstruktory inicializují členské proměnné objektu přímo.

Příklad

// 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 se odfoukne CRect pohybem stran směrem ke středu.

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
Určuje počet jednotek k deflaci levé a pravé strany CRect.

y
Určuje počet jednotek pro deflaci horní a dolní části .CRect

size
A SIZE nebo CSize určuje počet jednotek, které se mají deflatovat CRect. Hodnota cx určuje počet jednotek pro deflaci levé a pravé strany a cy hodnota určuje počet jednotek pro deflaci horní a dolní strany.

lpRect
Odkazuje na RECT strukturu nebo CRect určuje počet jednotek, které mají být na každé straně deflace.

l
Určuje počet jednotek k deflaci levé strany CRect.

t
Určuje počet jednotek, které mají být v horní části CRect.

r
Určuje počet jednotek k deflaci pravé strany CRect.

b
Určuje počet jednotek k deflaci dolní části .CRect

Poznámky

Uděláte to tak, že DeflateRect přidáte jednotky vlevo a nahoře a od pravého a dolního okraje odečtete jednotky. Parametry DeflateRect jsou podepsané hodnoty; kladné hodnoty jsou deflate CRect a záporné hodnoty nafukují.

První dvě přetížení deflate oba páry protilehlých stran CRect tak, aby její celková šířka byla snížena o dva krát x (nebo cx) a její celková výška je snížena o dva krát y (nebo cy). Druhé dvě přetížení deflaují každou stranu CRect nezávisle na ostatních.

Příklad

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`

Určuje, zda CRect se rovná danému obdélníku.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parametry

lpRect
Odkazuje na RECT strukturu nebo CRect objekt, který obsahuje souřadnice obdélníku v levém horním a pravém dolním rohu.

Návratová hodnota

Nenulové, pokud dva obdélníky mají stejné horní, levé, dolní a pravé hodnoty; jinak 0.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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`

Vypočítá výšku CRect odečtením nejvyšší hodnoty od nejnižší hodnoty.

int Height() const throw();

Návratová hodnota

Výška CRect.

Poznámky

Výsledná hodnota může být záporná.

Poznámka:

Obdélník musí být normalizován nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníku.

Příklad

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

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

`CRect::InflateRect`

InflateRect nafoukne CRect pohybem stran od středu.

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
Určuje počet jednotek, které se mají nafouknout levou a pravou stranou CRect.

y
Určuje počet jednotek, které se mají nafouknout nahoru a dole .CRect

size
A SIZE nebo CSize určuje počet jednotek, které se mají nafouknout CRect. Hodnota cx určuje počet jednotek, které se mají nafouknout na levé a pravé straně, a cy hodnota určuje počet jednotek, které se mají nafouknout nahoru a dole.

lpRect
Odkazuje na RECT strukturu nebo CRect určuje počet jednotek, které se mají nafouknout na každou stranu.

l
Určuje počet jednotek, které se mají nafouknout levou stranu CRect.

t
Určuje počet jednotek, které se mají nafouknout na začátek CRect.

r
Určuje počet jednotek, které se mají nafouknout na pravé straně CRect.

b
Určuje počet jednotek, které se mají nafouknout na konec CRect.

Poznámky

Uděláte to tak, že InflateRect odečte jednotky zleva a shora a přidá jednotky doprava a dolů. Parametry InflateRect jsou podepsané hodnoty; kladné hodnoty nafouknou CRect a záporné hodnoty ji deflaují.

První dvě přetížení nafoukne oba páry opačných stran CRect tak, aby jeho celková šířka byla zvýšena o dvě krát x (nebo cx) a její celková výška se zvyšuje o dvěkrát y (nebo cy). Druhé dvě přetížení nafukují každou stranu CRect nezávisle na ostatních.

Příklad

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 Rovná se průsečíku dvou existujících obdélníků.

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

Parametry

lpRect1
Odkazuje na RECT strukturu nebo CRect objekt, který obsahuje zdrojový obdélník.

lpRect2
Odkazuje na RECT strukturu nebo CRect objekt, který obsahuje zdrojový obdélník.

Návratová hodnota

Nenulové, pokud průsečík není prázdný; 0, pokud je průsečík prázdný.

Poznámky

Průsečík je největší obdélník obsažený v obou existujících obdélníkech.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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`

Určuje, zda CRect je prázdná.

BOOL IsRectEmpty() const throw();

Návratová hodnota

Nenulové, pokud CRect je prázdné; 0, pokud CRect není prázdné.

Poznámky

Obdélník je prázdný, pokud je šířka nebo výška 0 nebo záporná. Liší se od IsRectNull, který určuje, zda všechny souřadnice obdélníku jsou nula.

Poznámka:

Obdélník musí být normalizován nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníku.

Příklad

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`

Určuje, zda jsou všechny hodnoty v horní, levé, dolní a pravé CRect části rovny 0.

BOOL IsRectNull() const throw();

Návratová hodnota

Nenulové, pokud CRectjsou horní, levé, dolní a pravé hodnoty rovny 0, jinak 0.

Poznámky

Liší se od IsRectEmpty, který určuje, zda je obdélník prázdný.

Příklad

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`

Voláním této funkce přesunete obdélník na absolutní souřadnici x určenou xpomocí .

void MoveToX(int x) throw();

Parametry

x
Absolutní souřadnice x pro levý horní roh obdélníku.

Příklad

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`

Voláním této funkce přesunete obdélník na absolutní souřadnice x a y zadané.

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

Parametry

x
Absolutní souřadnice x pro levý horní roh obdélníku.

y
Absolutní souřadnice y pro levý horní roh obdélníku.

point
Struktura POINT určující absolutní levý horní roh obdélníku.

Příklad

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`

Voláním této funkce přesunete obdélník na absolutní souřadnici y určenou ypomocí .

void MoveToY(int y) throw();

Parametry

y
Absolutní souřadnice y pro levý horní roh obdélníku.

Příklad

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 CRect se tak, aby výška i šířka byly kladné.

void NormalizeRect() throw();

Poznámky

Obdélník je normalizován pro umístění čtvrtého kvadrantu, který systém Windows obvykle používá pro souřadnice. NormalizeRect porovná nejvyšší a nejnižší hodnoty a prohodí je, pokud je nejvyšší než dolní hodnota. Podobně prohodí hodnoty zleva a doprava, pokud je vlevo větší než vpravo. Tato funkce je užitečná při práci s různými režimy mapování a invertovanými obdélníky.

Poznámka:

Následující CRect členské funkce vyžadují normalizované obdélníky, aby fungovaly správně: Height, Width, , SizeIsRectEmpty, PtInRect, EqualRect, UnionRect, IntersectRect, operator ==SubtractRect, operator !=, operator |operator |=, operator &a operator &=.

Příklad

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

`CRect::OffsetRect`

Přesune CRect podle zadaných posunů.

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

Parametry

x
Určuje množství, které se má přesunout doleva nebo doprava. Musí být záporná, aby se přesunula doleva.

y
Určuje množství, které se má přesunout nahoru nebo dolů. Musí být negativní, aby se přesunul nahoru.

point
POINT Obsahuje strukturu nebo CPoint objekt určující obě dimenze, o které se mají přesunout.

size
SIZE Obsahuje strukturu nebo CSize objekt určující obě dimenze, o které se mají přesunout.

Poznámky

Přesune CRectx jednotky podél osy x a y jednotek podél osy y. Hodnoty x a y parametry jsou podepsané, takže CRect je možné je přesunout doleva nebo doprava a nahoru nebo dolů.

Příklad

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`Převede na `CRect` .`LPCRECT`

operator LPCRECT() const throw();

Poznámky

Při použití této funkce nepotřebujete operátor address-of (&). Tento operátor se automaticky použije při předání objektu CRect do funkce, která očekává .LPCRECT

`CRect::operator LPRECT`

Převede na CRect .LPRECT

operator LPRECT() throw();

Poznámky

Při použití této funkce nepotřebujete operátor address-of (&). Tento operátor se automaticky použije při předání objektu CRect do funkce, která očekává .LPRECT

Příklad

Podívejte se na příklad pro CRect::operator LPCRECT.

`CRect::operator =`

srcRect Přiřadí .CRect

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

Parametry

srcRect
Odkazuje na zdrojový obdélník. Může to být nebo RECT CRect.

Příklad

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

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

`CRect::operator ==`

Určuje, zda rect je roven CRect porovnáním souřadnic jejich levého horního a pravého dolního rohu.

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

Parametry

rect
Odkazuje na zdrojový obdélník. Může to být nebo RECT CRect.

Návratová hodnota

Nenulová, pokud je rovna; jinak 0.

Poznámky

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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

Určuje, zda rect se nerovná CRect porovnáním souřadnic jejich levého horního a pravého dolního rohu.

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

Parametry

rect
Odkazuje na zdrojový obdélník. Může to být nebo RECT CRect.

Návratová hodnota

Nenulové, pokud není rovno; jinak 0.

Poznámky

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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

První dvě přetížení se přesunou CRect o zadané posuny.

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

Parametry

point
Struktura POINT nebo CPoint objekt, který určuje počet jednotek pro přesunutí obdélníku.

size
Struktura SIZE nebo CSize objekt, který určuje počet jednotek pro přesunutí obdélníku.

lpRect
Odkazuje na RECT strukturu nebo CRect objekt obsahující počet jednotek, které se mají nafouknout každou stranu CRect.

Poznámky

Hodnoty parametru x a y (nebo cx a cy) se přidají do CRect.

Třetí přetížení se nafoukne CRect počtem jednotek zadaných v každém členu parametru.

Příklad

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

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

`CRect::operator -=`

První dvě přetížení se přesunou CRect o zadané posuny.

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

Parametry

point
Struktura POINT nebo CPoint objekt, který určuje počet jednotek pro přesunutí obdélníku.

size
Struktura SIZE nebo CSize objekt, který určuje počet jednotek pro přesunutí obdélníku.

lpRect
Odkazuje na RECT strukturu nebo CRect objekt, který obsahuje počet jednotek k deflaci každé strany CRect.

Poznámky

Hodnoty parametru x a y (nebo cx a cy) se odečítají od CRect.

Třetí přetížení se odfoukne CRect počtem jednotek zadaných v každém členu parametru. Všimněte si, že toto přetížení funguje jako DeflateRect.

Příklad

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

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

`CRect::operator &=`

Nastaví CRect se rovnající průsečíku CRect a rect.

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

Parametry

rect
Obsahuje nebo RECT CRect.

Poznámky

Průsečík je největší obdélník, který je obsažen v obou obdélníkech.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

Podívejte se na příklad pro CRect::IntersectRect.

`CRect::operator |=`

Nastaví CRect se rovná sjednocení a CRect rect.

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

Parametry

rect
Obsahuje nebo CRect RECT.

Poznámky

Sjednocení je nejmenší obdélník, který obsahuje oba zdrojové obdélníky.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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

První dvě přetížení vrátí CRect objekt, který je roven CRect vytěsněno zadanými posuny.

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

Parametry

point
Struktura POINT nebo CPoint objekt, který určuje počet jednotek pro přesunutí návratové hodnoty.

size
Struktura SIZE nebo CSize objekt, který určuje počet jednotek pro přesunutí návratové hodnoty.

lpRect
Odkazuje na RECT strukturu nebo CRect objekt obsahující počet jednotek, které se mají nafouknout na každou stranu návratové hodnoty.

Návratová hodnota

Výsledek CRect přesunutí nebo nafouknutí CRect počtem jednotek zadaných v parametru.

Poznámky

Parametry parametru x a y (nebo cx a cy) se přidají do CRectpozice.

Třetí přetížení vrátí novou CRect hodnotu, která se rovná CRect nafouknutí počtem jednotek zadaných v každém členu parametru.

Příklad

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

První dvě přetížení vrátí CRect objekt, který je roven CRect vytěsněno zadanými posuny.

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

Parametry

point
Struktura POINT nebo CPoint objekt, který určuje počet jednotek pro přesunutí návratové hodnoty.

size
Struktura SIZE nebo CSize objekt, který určuje počet jednotek pro přesunutí návratové hodnoty.

lpRect
Odkazuje na RECT strukturu nebo CRect objekt, který obsahuje počet jednotek k deflaci každé strany návratové hodnoty.

Návratová hodnota

Výsledek CRect přesunutí nebo odfouknutí CRect počtem jednotek zadaných v parametru.

Poznámky

Parametry parametru x a y (nebo cx a cy) se odečtou od CRectpozice parametru.

Třetí přetížení vrátí novou CRect hodnotu, která se rovná CRect deflated podle počtu jednotek zadaných v každém členu parametru. Všimněte si, že toto přetížení funguje jako DeflateRect, ne SubtractRect.

Příklad

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 &`

CRect Vrátí průnik CRect a rect2.

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

Parametry

rect2
Obsahuje nebo RECT CRect.

Návratová hodnota

To CRect je průsečík a rect2CRect .

Poznámky

Průsečík je největší obdélník, který je obsažen v obou obdélníkech.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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

Vrátí sjednocování CRect a CRect rect2.

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

Parametry

rect2
Obsahuje nebo RECT CRect.

Návratová hodnota

To CRect je sjednocení CRect a rect2.

Poznámky

Sjednocení je nejmenší obdélník, který obsahuje oba obdélníky.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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`

Určuje, zda zadaný bod leží v rámci CRect.

BOOL PtInRect(POINT point) const throw();

Parametry

point
POINT Obsahuje strukturu nebo CPoint objekt.

Návratová hodnota

Nenulové, pokud bod leží uvnitř CRect; jinak 0.

Poznámky

Bod je uvnitř CRect , pokud leží na levé nebo horní straně nebo je uvnitř všech čtyř stran. Bod na pravé nebo dolní straně je venku CRect.

Poznámka:

Obdélník musí být normalizován nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníku.

Příklad

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`

Nastaví rozměry CRect na zadané souřadnice.

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

Parametry

x1
Určuje souřadnici x levého horního rohu.

y1
Určuje souřadnici y levého horního rohu.

x2
Určuje souřadnici x pravého dolního rohu.

y2
Určuje souřadnici y pravého dolního rohu.

Příklad

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

`CRect::SetRectEmpty`

Vytvoří CRect obdélník null nastavením všech souřadnic na nulu.

void SetRectEmpty() throw();

Příklad

CRect rect;
rect.SetRectEmpty();

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

`CRect::SIZE`

Návratová cx hodnota a cy členové obsahují výšku a šířku CRect.

CSize Size() const throw();

Návratová hodnota

Objekt CSize , který obsahuje velikost CRect.

Poznámky

Výška nebo šířka může být záporná.

Poznámka:

Obdélník musí být normalizován nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníku.

Příklad

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

`CRect::SubtractRect`

Činí dimenze CRect rovny odčítání lpRectSrc2 od lpRectSrc1.

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

Parametry

lpRectSrc1
Odkazuje na RECT strukturu nebo CRect objekt, ze kterého se má obdélník odečíst.

lpRectSrc2
Odkazuje na RECT strukturu nebo CRect objekt, který se má odečíst od obdélníku, na který lpRectSrc1 odkazuje parametr.

Návratová hodnota

Nenulové, pokud je funkce úspěšná; jinak 0.

Poznámky

Odčítání je nejmenší obdélník, který obsahuje všechny body, lpRectScr1 které nejsou v průsečíku lpRectScr1 a lpRectScr2.

Obdélník určený znaky se nezmění, pokud se obdélník určený lpRectSrc1 tímto obdélníkem lpRectSrc2 lpRectSrc1 úplně nepřekrývá aspoň jedním ze směrů x nebo y.

Pokud lpRectSrc1 by například byla (10 10, 100 100) a lpRectSrc2 byla (50 50, 150 150), obdélník, na který odkazuje lpRectSrc1 , by se při vrácení funkce nezměnil. Pokud lpRectSrc1 by byla (10,10, 100,100) a lpRectSrc2 byla (50,10, 150,150), ale obdélník, na který odkazuje lpRectSrc1 , by obsahoval souřadnice (10,10, 50,100) při vrácení funkce.

SubtractRect není stejný jako operátor – ani operátor -=. Ani jeden z těchto operátorů nikdy nevolá SubtractRect.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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`

Souřadnice jsou vráceny jako odkaz na CPoint objekt, který je obsažen v CRect.

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

Návratová hodnota

Souřadnice levého horního rohu obdélníku.

Poznámky

Tuto funkci můžete použít k získání nebo nastavení levého horního rohu obdélníku. Na levé straně operátoru přiřazení nastavte roh pomocí této funkce.

Příklad

Podívejte se na příklad pro CRect::CenterPoint.

`CRect::UnionRect`

Zkótuje CRect stejnou sjednocování dvou zdrojových obdélníků.

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

Parametry

lpRect1
Odkazuje na RECT zdrojový obdélník nebo CRect který obsahuje zdrojový obdélník.

lpRect2
Odkazuje na RECT zdrojový obdélník nebo CRect který obsahuje zdrojový obdélník.

Návratová hodnota

Nenulové, pokud sjednocení není prázdné; 0, pokud je sjednocení prázdné.

Poznámky

Sjednocení je nejmenší obdélník, který obsahuje oba zdrojové obdélníky.

Windows ignoruje rozměry prázdného obdélníku; to znamená obdélník, který nemá žádnou výšku nebo nemá žádnou šířku.

Poznámka:

Oba obdélníky musí být normalizovány nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníků.

Příklad

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`

Vypočítá šířku CRect odečtením levé hodnoty od pravé hodnoty.

int Width() const throw();

Návratová hodnota

Šířka CRect.

Poznámky

Šířka může být záporná.

Poznámka:

Obdélník musí být normalizován nebo tato funkce může selhat. Před voláním této funkce můžete volat NormalizeRect normalizaci obdélníku.

Příklad

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

Viz také

CPoint Třída
CSize Třída
RECT

Sdílet prostřednictvím

CRect Třída

Syntaxe

Členové

Veřejné konstruktory

Veřejné metody

Veřejné operátory

Poznámky

Hierarchie dědičnosti

Požadavky

CRect::BottomRight

Návratová hodnota

Poznámky

Příklad

CRect::CenterPoint

Návratová hodnota

Příklad

CRect::CopyRect

Parametry

Příklad

CRect::CRect

Parametry

Poznámky

Příklad

CRect::DeflateRect

Parametry

Poznámky

Příklad

CRect::EqualRect

Parametry

Návratová hodnota

Příklad

CRect::Height

Návratová hodnota

Poznámky

Příklad

CRect::InflateRect

Parametry

Poznámky

Příklad

CRect::IntersectRect

Parametry

Návratová hodnota

Poznámky

Příklad

CRect::IsRectEmpty

Návratová hodnota

Poznámky

Příklad

CRect::IsRectNull

Návratová hodnota

Poznámky

Příklad

CRect::MoveToX

Parametry

Příklad

CRect::MoveToXY

Parametry

Příklad

CRect::MoveToY

Parametry

Příklad

CRect::NormalizeRect

Poznámky

Příklad

CRect::OffsetRect

Parametry

Poznámky

Příklad

CRect::operator LPCRECTPřevede na CRect .LPCRECT

Poznámky

CRect::operator LPRECT

Poznámky

Příklad

CRect::operator =

Parametry

Příklad

CRect::operator ==

Parametry

Návratová hodnota

`CRect` Třída

`CRect::BottomRight`

`CRect::CenterPoint`

`CRect::CopyRect`

`CRect::CRect`

`CRect::DeflateRect`

`CRect::EqualRect`

`CRect::Height`

`CRect::InflateRect`

`CRect::IntersectRect`

`CRect::IsRectEmpty`

`CRect::IsRectNull`

`CRect::MoveToX`

`CRect::MoveToXY`

`CRect::MoveToY`

`CRect::NormalizeRect`

`CRect::OffsetRect`

`CRect::operator LPCRECT`Převede na `CRect` .`LPCRECT`

`CRect::operator LPRECT`

`CRect::operator =`

`CRect::operator ==`

`CRect::operator !=`

`CRect::operator +=`

`CRect::operator -=`

`CRect::operator &=`

`CRect::operator |=`

`CRect::operator +`

`CRect::operator -`

`CRect::operator &`

`CRect::operator |`

`CRect::PtInRect`

`CRect::SetRect`

`CRect::SetRectEmpty`

`CRect::SIZE`

`CRect::SubtractRect`

`CRect::TopLeft`

`CRect::UnionRect`