CRect osztály

Hasonló a Windows-struktúrához RECT .

Szemantika

class CRect : public tagRECT

Tagok

Nyilvános konstruktorok

Név	Leírás
CRect::CRect	Egy CRect objektumot hoz létre.

Nyilvános metódusok

Név	Leírás
CRect::BottomRight	A jobb alsó pontját CRectadja vissza.
CRect::CenterPoint	A középpontját CRectadja vissza.
CRect::CopyRect	Másolja a forrás téglalap méreteit a következőre CRect: .
CRect::DeflateRect	Csökkenti a szélességet és a magasságot CRect.
CRect::EqualRect	Meghatározza, hogy egyenlő-e CRect a megadott téglalappal.
CRect::Height	Kiszámítja a magasságot CRect.
CRect::InflateRect	Növeli a szélességet és a magasságot CRect.
CRect::IntersectRect	Két téglalap metszetével egyenlő halmaz CRect .
CRect::IsRectEmpty	Meghatározza, hogy üres-e CRect . CRect üres, ha a szélesség és/vagy a magasság 0.
CRect::IsRectNull	Meghatározza, hogy a top, bottom, left, és right tag változók mind egyenlőek-e 0-nak.
CRect::MoveToX	Ugrás CRect a megadott x koordinátára.
CRect::MoveToXY	Ugrás CRect a megadott x és y koordinátákra.
CRect::MoveToY	Ugrás CRect a megadott y koordinátára.
CRect::NormalizeRect	Szabványosítja a magasságot és a szélességet CRect.
CRect::OffsetRect	A megadott eltolások szerint mozog CRect .
CRect::PtInRect	Meghatározza, hogy a megadott pont belül van-e CRect.
CRect::SetRect	A dimenzióit állítja CRectbe.
CRect::SetRectEmpty	Üres téglalapra van adva CRect (az összes koordináta értéke 0).
CRect::Size	Kiszámítja a méretet CRect.
CRect::SubtractRect	Kivon egy téglalapot a másikból.
CRect::TopLeft	A bal felső pontot CRectadja vissza.
CRect::UnionRect	Két téglalap összevonásával egyenlő halmazok CRect .
CRect::Width	Kiszámítja a szélességét CRect.

Nyilvános operátorok

Név	Leírás
CRect::operator -	Kivonja a megadott eltolásokat a megadott eltolásokból CRect vagy deflatesekből CRect , és visszaadja az eredményül kapott CRectértéket.
CRect::operator LPCRECT	Átalakítja az a-t CRect egy LPCRECT.
CRect::operator LPRECT	Átalakítja az a-t CRect egy LPRECT.
CRect::operator !=	Meghatározza, hogy nem egyenlő-e CRect téglalappal.
CRect::operator &	Létrehozza a téglalap és a téglalap metszetét CRect , és visszaadja az eredményül kapott CRectértéket.
CRect::operator &=	A metszéspont és a téglalap metszéspontjával CRect egyenlő értékeket állít beCRect.
CRect::operator |	Létrehozza a téglalap és a téglalap egyesítését CRect , és visszaadja az eredményül kapott CRectértéket.
CRect::operator |=	Egy téglalap és egy téglalap egyesítésével CRect egyenlő értékeket állít beCRect.
CRect::operator +	Hozzáadja a megadott eltolásokat vagy CRect felfújja CRect azokat, és visszaadja az eredményül CRectkapott értéket.
CRect::operator +=	Hozzáadja a megadott eltolásokat vagy CRect felfújja azokat CRect.
CRect::operator =	Egy téglalap méretének másolása a következőre CRect: .
CRect::operator -=	Kivonja a megadott eltolásokat a megadott eltolásokból CRect vagy deflatesekből CRect.
CRect::operator ==	Meghatározza, hogy egy téglalap egyenlő-e CRect .

Megjegyzések

CRectaz objektumok és a Windows-struktúrák RECT manipulálására CRect szolgáló tagfüggvényeket is tartalmaz.

Az CRect objektumok átadhatók függvényparaméterként bárhol, ahol egy RECT struktúra, LPCRECTvagy LPRECT átadható.

Megjegyzés:

Ez az osztály a tagRECT szerkezetből származik. (A név tagRECT a struktúra kevésbé gyakran használt neveRECT.) Ez azt jelenti, hogy a struktúra adattagja (, és right) a RECTCRect.bottomtopleft

Az A CRect olyan tagváltozókat tartalmaz, amelyek egy téglalap bal felső és jobb alsó pontjait határozzák meg.

A beállításnál CRectkörültekintően kell konstruálnia, hogy normalizálva legyen – vagyis a bal koordináta értéke kisebb legyen a jobbnál, a felső pedig kisebb legyen az alsónál. A (10,10) és a jobb alsó sarok (20,20) például egy normalizált téglalapot határoz meg, de a (20,20) és a jobb alsó (10,10) bal felső része nem normalizált téglalapot határoz meg. Ha a téglalap nincs normalizálva, sok CRect tagfüggvény helytelen eredményeket adhat vissza. (A függvények listáját itt találja CRect::NormalizeRect .) Mielőtt normalizált téglalapokat igénylő függvényt hívna meg, normalizálhatja a nem normalizált téglalapokat a NormalizeRect függvény meghívásával.

A tagfüggvények és a CDC::DPtoLPCDC::LPtoDP tagfüggvények manipulálásakor CRect körültekintően kell eljárni. Ha egy megjelenítési környezet leképezési módja olyan, hogy az y-mértéke negatív, mint az , MM_LOENGLISHakkor CDC::DPtoLP átalakítja a CRect képet úgy, hogy a felső része nagyobb legyen, mint az alsó. Az olyan függvények, mint például HeightSize az átalakított CRectmagasság negatív értékeit adja vissza, a téglalap pedig nem normalizálódik.

Túlterhelt CRect operátorok használatakor az első operandusnak egy CRect; a második lehet RECT szerkezet vagy CRect objektum.

Öröklési hierarchia

tagRECT

CRect

Követelmények

fejléc:atltypes.h

CRect::BottomRight

A koordinátákat a rendszer egy CPoint olyan objektumra mutató hivatkozásként adja vissza, amely a fájlban CRecttalálható.

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

Visszaadott érték

A téglalap jobb alsó sarkának koordinátái.

Megjegyzések

Ezzel a függvénnyel lekérheti vagy beállíthatja a téglalap jobb alsó sarkát. Állítsa be a sarokban ezt a függvényt a hozzárendelési operátor bal oldalán.

példa

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

Kiszámítja a középpontot CRect a bal és a jobb oldali értékek hozzáadásával, a kettővel való osztással, a felső és az alsó értékek hozzáadásával, valamint a kettővel való osztással.

CPoint CenterPoint() const throw();

Visszaadott érték

Egy CPoint objektum, amely a középpontja CRect.

példa

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

Másolja a téglalapot a lpSrcRect következőbe CRect: .

void CopyRect(LPCRECT lpSrcRect) throw();

Paraméterek

lpSrcRect
RECT A másolandó szerkezetre vagy CRect objektumra mutat.

példa

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

Egy CRect objektumot hoz létre.

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

Paraméterek

l
A bal oldali pozíciót CRectadja meg.

t
Megadja a felső elemet CRect.

r
A megfelelő pozíciót CRectadja meg.

b
A alját CRectadja meg.

srcRect
A szerkezetre hivatkozik a RECT következő koordinátákkal CRect: .

lpSrcRect
A szerkezetre mutat a RECT következő koordinátákkal CRect: .

point
Megadja a létrehozandó téglalap forráspontját. A bal felső saroknak felel meg.

size
A létrehozandó téglalap bal felső sarkától a jobb alsó sarokig történő elmozdulást adja meg.

topLeft
A bal felső pozíciót CRectadja meg.

bottomRight
A jobb alsó sarkában lévő pozíciót CRectadja meg.

Megjegyzések

Ha nem ad meg argumentumokat, lefttoprightbottom akkor a tagok értéke 0.

A CRect(const RECT&) és CRect(LPCRECT) konstruktorok végrehajtanak egy CopyRect. A többi konstruktor közvetlenül inicializálja az objektum tagváltozóit.

példa

// 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 lefedi CRect az oldalait a középpontja felé mozgatva.

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

Paraméterek

x
Megadja, hogy hány egység legyen deflálva a bal és a jobb oldalon CRect.

y
Megadja, hogy hány egység legyen deflálva a lista tetején és alján CRect.

size
A SIZE vagy CSize amely megadja a deflálni CRectkívánt egységek számát. Az cx érték a bal és a jobb oldali oldal deflálásához tartozó egységek számát adja meg, az cy érték pedig a felül és alul lévő egységek számát határozza meg.

lpRect
Egy szerkezetre RECT mutat, vagy CRect megadja az egyes oldalokat deflálandó egységek számát.

l
Megadja, hogy hány egység legyen deflálva a bal oldalon CRect.

t
Megadja, hogy hány egység legyen deflálva a lista tetején CRect.

r
Megadja, hogy hány egység legyen deflálva a jobb oldalon CRect.

b
Megadja az aljára CRectdeflálandó egységek számát.

Megjegyzések

Ehhez hozzáadja az egységeket a bal és a felső részhez, DeflateRect és kivonja az egységeket jobbról és alulról. A paraméterek DeflateRect aláírt értékek; a pozitív értékek deflálnak CRect , a negatív értékek pedig felfújják.

Az első két túlterhelés mindkét ellentétes oldalpárját CRect eltéríti, így a teljes szélessége kétszer x (vagy cx) csökken, és a teljes magassága kétszer y (vagy cy) csökken. A másik két túlterhelés egymástól függetlenül deflál CRect .

példa

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

Meghatározza, hogy egyenlő-e CRect a megadott téglalappal.

BOOL EqualRect(LPCRECT lpRect) const throw();

Paraméterek

lpRect
RECT Egy téglalap bal felső és jobb alsó sarkának koordinátáit tartalmazó szerkezetre vagy CRect objektumra mutat.

Visszaadott érték

Nonzero, ha a két téglalapnak ugyanaz a felső, bal, alsó és jobb értéke van; egyéb esetben 0.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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

Kiszámítja a magasságot CRect úgy, hogy kivonja a felső értéket az alsó értékből.

int Height() const throw();

Visszaadott érték

A magasság.CRect

Megjegyzések

Az eredményül kapott érték negatív lehet.

Megjegyzés:

A téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalap normalizálására.

példa

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

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

CRect::InflateRect

InflateRect úgy felfújja CRect , hogy az oldalait elmozdítja a középponttól.

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

Paraméterek

x
Megadja, hogy hány egység legyen felfújva a bal és a jobb oldalon CRect.

y
Megadja azoknak a egységeknek a számát, amelyeket a felső és az alsó CRectrészre kell felfújni.

size
A SIZE vagy CSize amely megadja a felfújandó CRectegységek számát. Az cx érték a bal és a jobb oldalt felfújni kívánt egységek számát adja meg, az cy érték pedig a felül és alul felfújandó egységek számát határozza meg.

lpRect
Egy struktúrára RECT mutat, vagy CRect megadja az egyes oldalokat felfújó egységek számát.

l
Megadja, hogy hány egység legyen felfújva a bal oldalon CRect.

t
Megadja azoknak a egységeknek a számát, amelyeket fel szeretne fújni.CRect

r
Megadja, hogy hány egység legyen a jobb oldalon CRect.

b
Megadja azoknak az egységeknek a számát, amelyeket fel szeretne fújni.CRect

Megjegyzések

Ehhez kivonja az egységeket balról és felülről, InflateRect és hozzáadja az egységeket a jobb és alsó részhez. A paraméterek InflateRect aláírt értékek; a pozitív értékek felfúvódnak CRect , a negatív értékek pedig deflálnak.

Az első két túlterhelés mindkét ellentétes oldalpárját CRect felfújja úgy, hogy teljes szélessége kétszer x (vagy cx) növelve legyen, és teljes magassága kétszeresével y (vagy cy) növelve legyen. A másik két túlterhelés egymástól függetlenül felfújja CRect mindkét oldalt.

példa

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 Két meglévő téglalap metszetével egyenlő.

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

Paraméterek

lpRect1
Egy forrás téglalapot tartalmazó struktúrára RECT vagy CRect objektumra mutat.

lpRect2
Egy forrás téglalapot tartalmazó struktúrára RECT vagy CRect objektumra mutat.

Visszaadott érték

Nonzero, ha a metszet nem üres; 0, ha a metszet üres.

Megjegyzések

A metszet a két meglévő téglalap legnagyobb téglalapja.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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

Meghatározza, hogy üres-e CRect .

BOOL IsRectEmpty() const throw();

Visszaadott érték

Nonzero ha CRect üres; 0, ha CRect nem üres.

Megjegyzések

A téglalap üres, ha a szélesség és/vagy a magasság 0 vagy negatív. Különbözik attól IsRectNull, amely meghatározza, hogy a téglalap összes koordinátája nulla-e.

Megjegyzés:

A téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalap normalizálására.

példa

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

Azt határozza meg, hogy a felső, a bal, az alsó és a jobb értékek CRect egyenlők-e 0-nak.

BOOL IsRectNull() const throw();

Visszaadott érték

Nonzero, ha CRect's top, left, bottom, and right values is equal to 0; otherwise 0.

Megjegyzések

Eltér attól IsRectEmpty, amely meghatározza, hogy a téglalap üres-e.

példa

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

A függvény meghívásával helyezze át a téglalapot a megadott xabszolút x koordinátára.

void MoveToX(int x) throw();

Paraméterek

x
A téglalap bal felső sarkának abszolút x koordinátája.

példa

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

A függvény meghívásával helyezze át a téglalapot a megadott abszolút x- és y koordinátákra.

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

Paraméterek

x
A téglalap bal felső sarkának abszolút x koordinátája.

y
A téglalap bal felső sarkának abszolút y koordinátája.

point
A POINT téglalap abszolút bal felső sarkát meghatározó struktúra.

példa

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

A függvény meghívásával helyezze át a téglalapot a megadott yabszolút y koordinátára.

void MoveToY(int y) throw();

Paraméterek

y
A téglalap bal felső sarkának abszolút y koordinátája.

példa

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

Normalizálja CRect , hogy mind a magasság, mind a szélesség pozitív legyen.

void NormalizeRect() throw();

Megjegyzések

A téglalap normalizálva van a negyedik negyedes elhelyezéshez, amelyet a Windows általában a koordinátákhoz használ. NormalizeRect összehasonlítja a felső és az alsó értékeket, és felcseréli őket, ha a felső nagyobb, mint az alsó. Hasonlóképpen felcseréli a bal és a jobb értéket, ha a bal nagyobb, mint a jobb. Ez a függvény akkor hasznos, ha különböző leképezési módokat és fordított téglalapokat kezel.

Megjegyzés:

A következő CRect tagfüggvények normalizált téglalapokat igényelnek a megfelelő működéshez: Height, Width, , Size, PtInRectIsRectEmpty, SubtractRectUnionRectoperator ==IntersectRectEqualRectoperator |operator |=operator !=operator &és .operator &=

példa

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

CRect::OffsetRect

A megadott eltolások szerint mozog CRect .

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

Paraméterek

x
A balra vagy jobbra mozgatni kívánt összeget adja meg. Balra mozgáshoz negatívnak kell lennie.

y
Megadja a felfelé vagy lefelé mozgatni kívánt összeget. Negatívnak kell lennie a feljebb lépéshez.

point
Olyan struktúrát POINT vagy CPoint objektumot tartalmaz, amely mindkét dimenziót meghatározza, amellyel áthelyezhető.

size
Olyan struktúrát SIZE vagy CSize objektumot tartalmaz, amely mindkét dimenziót meghatározza, amellyel áthelyezhető.

Megjegyzések

Az egységek mozgatása CRectx az x tengely és y az egységek mentén az y tengely mentén. A x paraméterek aláírt y értékek, ezért CRect áthelyezhetők balra vagy jobbra, illetve felfelé vagy lefelé.

példa

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

Átalakítja az a-t CRect egy LPCRECT.

operator LPCRECT() const throw();

Megjegyzések

Ha ezt a függvényt használja, nincs szükség a (&) cím operátorra. Ezt az operátort a rendszer automatikusan használja, ha egy objektumot CRect egy olyan függvénynek ad át, amely egy LPCRECT.

CRect::operator LPRECT

Átalakítja az a-t CRect egy LPRECT.

operator LPRECT() throw();

Megjegyzések

Ha ezt a függvényt használja, nincs szükség a (&) cím operátorra. Ezt az operátort a rendszer automatikusan használja, ha egy objektumot CRect egy olyan függvénynek ad át, amely egy LPRECT.

példa

Lásd a példát a CRect::operator LPCRECT.

CRect::operator =

srcRect CRectHozzá van rendelve.

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

Paraméterek

srcRect
Forrás téglalapra hivatkozik. Lehet egy RECT vagy CRect.

példa

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

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

CRect::operator ==

Meghatározza, hogy CRect egyenlő-e rect a bal felső és a jobb alsó sarok koordinátáinak összehasonlítása.

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

Paraméterek

rect
Forrás téglalapra hivatkozik. Lehet egy RECT vagy CRect.

Visszaadott érték

Nonzero, ha egyenlő; egyéb esetben 0.

Megjegyzések

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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

Meghatározza, hogy CRect nem egyenlő-e rect a bal felső és a jobb alsó sarok koordinátáinak összehasonlításával.

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

Paraméterek

rect
Forrás téglalapra hivatkozik. Lehet egy RECT vagy CRect.

Visszaadott érték

Nonzero, ha nem egyenlő; egyéb esetben 0.

Megjegyzések

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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

Az első két túlterhelés a megadott eltolások szerint mozog CRect .

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

Paraméterek

point
Olyan POINT struktúra vagy CPoint objektum, amely meghatározza a téglalap mozgatásához használandó egységek számát.

size
Olyan SIZE struktúra vagy CSize objektum, amely meghatározza a téglalap mozgatásához használandó egységek számát.

lpRect
Egy olyan szerkezetre vagy CRect objektumra RECT mutat, amely tartalmazza az egyes oldalokat CRectfelfújni kívánt egységek számát.

Megjegyzések

A paraméter x és (vagy cxcy) értékei hozzá lesznek adva a paraméterhez CRecty .

A harmadik túlterhelést a paraméter egyes részeiben megadott egységek száma növeli CRect .

példa

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

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

CRect::operator -=

Az első két túlterhelés a megadott eltolások szerint mozog CRect .

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

Paraméterek

point
Olyan POINT struktúra vagy CPoint objektum, amely meghatározza a téglalap mozgatásához használandó egységek számát.

size
Olyan SIZE struktúra vagy CSize objektum, amely meghatározza a téglalap mozgatásához használandó egységek számát.

lpRect
Egy olyan szerkezetre vagy CRect objektumra RECT mutat, amely tartalmazza a mértékegységek számát, amelyek az egyes oldalukon deflálnakCRect.

Megjegyzések

A paraméter x és (vagy cxcy) értékeit a rendszer kivonja a függvényből CRecty .

A harmadik túlterhelés a paraméter egyes részeiben megadott egységek számával töredezett CRect . Vegye figyelembe, hogy ez a túlterhelés a következőképpen DeflateRectműködik: .

példa

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

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

CRect::operator &=

A CRect metszéspont CRectrectés a .

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

Paraméterek

rect
RECT Egy vagy CRect.

Megjegyzések

A metszet a legnagyobb téglalap, amely mindkét téglalapban található.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

Lásd a példát a CRect::IntersectRect.

CRect::operator |=

A halmazok CRect megegyeznek CRect az és recta .

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

Paraméterek

rect
CRect Egy vagy RECT.

Megjegyzések

Az egyesítő a legkisebb téglalap, amely mindkét forrás téglalapot tartalmazza.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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 +

Az első két túlterhelés olyan CRect objektumot ad vissza, amelyet CRect a megadott eltolások elmozdítottak.

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

Paraméterek

point
Olyan POINT struktúra vagy CPoint objektum, amely meghatározza a visszatérési érték áthelyezéséhez használandó egységek számát.

size
Olyan SIZE struktúra vagy CSize objektum, amely meghatározza a visszatérési érték áthelyezéséhez használandó egységek számát.

lpRect
Olyan szerkezetre vagy CRect objektumra RECT mutat, amely a visszatérési érték mindkét oldalát felfújó egységek számát tartalmazza.

Visszaadott érték

A CRect paraméterben megadott egységek számával történő áthelyezés vagy felfújás CRect eredménye.

Megjegyzések

A rendszer hozzáadja a paraméter és y (vagy cxcy) paramétereit a pozícióhozCRect.x

A harmadik túlterhelés egy olyan újat CRect ad vissza, amely a paraméter egyes részeiben megadott egységek számával egyenlő CRect .

példa

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 -

Az első két túlterhelés olyan CRect objektumot ad vissza, amelyet CRect a megadott eltolások elmozdítottak.

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

Paraméterek

point
Olyan POINT struktúra vagy CPoint objektum, amely meghatározza a visszatérési érték áthelyezéséhez használandó egységek számát.

size
Olyan SIZE struktúra vagy CSize objektum, amely meghatározza a visszatérési érték áthelyezéséhez használandó egységek számát.

lpRect
Olyan szerkezetre vagy CRect objektumra RECT mutat, amely a visszatérési érték egyes oldalainak deflálásához használandó egységek számát tartalmazza.

Visszaadott érték

A CRect paraméterben megadott egységek számával történő áthelyezés vagy leolvasztás CRect eredménye.

Megjegyzések

A paraméter x és (vagy cxcy) paramétereket a rendszer kivonja a pozícióból CRecty .

A harmadik túlterhelés egy olyan újat CRect ad vissza, amely egyenlő CRect a paraméter egyes részeiben megadott egységek számával. Vegye figyelembe, hogy ez a túlterhelés a következőképpen DeflateRectműködik, nem SubtractRect.

példa

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 A rect2 és a rect2 metszetét CRect adja vissza.

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

Paraméterek

rect2
RECT Egy vagy CRect.

Visszaadott érték

A CRect , hogy a metszete CRect és rect2.

Megjegyzések

A metszet a legnagyobb téglalap, amely mindkét téglalapban található.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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 |

Egy olyan értéket CRect ad vissza, amely az és rect2a CRect .

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

Paraméterek

rect2
RECT Egy vagy CRect.

Visszaadott érték

A CRect , hogy az unió és CRectrect2.

Megjegyzések

Az egyesítő a legkisebb téglalap, amely mindkét téglalapot tartalmazza.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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

Meghatározza, hogy a megadott pont belül van-e CRect.

BOOL PtInRect(POINT point) const throw();

Paraméterek

point
Szerkezetet POINT vagy CPoint objektumot tartalmaz.

Visszaadott érték

Nonzero, ha a pont belül CRectvan; egyébként 0.

Megjegyzések

A pont belül CRect van, ha a bal vagy a felső oldalon helyezkedik el, vagy mind a négy oldalon belül van. A jobb vagy az alsó oldalon egy pont kívül CRectvan.

Megjegyzés:

A téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalap normalizálására.

példa

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

A megadott koordináták dimenzióit CRect állítja be.

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

Paraméterek

x1
A bal felső sarok x koordinátáját adja meg.

y1
A bal felső sarok y koordinátáját adja meg.

x2
A jobb alsó sarok x koordinátáját adja meg.

y2
A jobb alsó sarok y koordinátáját adja meg.

példa

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

CRect::SetRectEmpty

Null téglalapot hoz létre CRect úgy, hogy az összes koordinátát nullára állítja.

void SetRectEmpty() throw();

példa

CRect rect;
rect.SetRectEmpty();

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

CRect::SIZE

A cx visszatérési érték és cy a tagok tartalmazzák a magasságot és a szélességet CRect.

CSize Size() const throw();

Visszaadott érték

Olyan CSize objektum, amely a méretet CRecttartalmazza.

Megjegyzések

A magasság vagy a szélesség negatív lehet.

Megjegyzés:

A téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalap normalizálására.

példa

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

CRect::SubtractRect

Az egyenlő dimenziók CRect méretei a kivonásbóllpRectSrc2.lpRectSrc1

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

Paraméterek

lpRectSrc1
Arra a RECT szerkezetre vagy CRect objektumra mutat, amelyből egy téglalapot ki kell vonni.

lpRectSrc2
RECT A paraméter által lpRectSrc1 mutatott téglalapból kivonandó szerkezetre vagy CRect objektumra mutat.

Visszaadott érték

Nonzero, ha a függvény sikeres; egyéb esetben 0.

Megjegyzések

A kivonás a legkisebb téglalap, amely tartalmazza az összes pontot lpRectScr1 , amelyek nem a metszetében lpRectScr1 és lpRectScr2.

A megadott lpRectSrc1 téglalap változatlan marad, ha a megadott lpRectSrc2 téglalap nem fedi át teljesen az x vagy az y irányban megadott lpRectSrc1 téglalapot.

Ha például lpRectSrc1 (10,10, 100 100) és lpRectSrc2 (50,50, 150 150) lenne, akkor a függvény visszatérésekor a megadott lpRectSrc1 téglalap változatlan maradna. Ha lpRectSrc1 (10,10, 100,100) és lpRectSrc2 (50,10, 150,150) lenne, akkor azonban a függvény visszaadásakor a megadott lpRectSrc1 téglalap tartalmazza a koordinátákat (10,10, 50 100).

SubtractRect nem ugyanaz, mint az operátor - vagy operátor -=. Egyik operátor sem hív SubtractRect.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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

A koordinátákat a rendszer egy CPoint olyan objektumra mutató hivatkozásként adja vissza, amely a fájlban CRecttalálható.

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

Visszaadott érték

A téglalap bal felső sarkának koordinátái.

Megjegyzések

Ezzel a függvénnyel lekérheti vagy beállíthatja a téglalap bal felső sarkát. Állítsa be a sarokban ezt a függvényt a hozzárendelési operátor bal oldalán.

példa

Lásd a példát a CRect::CenterPoint.

CRect::UnionRect

A két forrás téglalap egyesítésével CRect egyenlő méreteket ad meg.

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

Paraméterek

lpRect1
Egy forrás téglalapot RECT tartalmazó vagy CRect azt tartalmazó téglalapra mutat.

lpRect2
Egy forrás téglalapot RECT tartalmazó vagy CRect azt tartalmazó téglalapra mutat.

Visszaadott érték

Nonzero, ha az unió nem üres; 0, ha az unió üres.

Megjegyzések

Az egyesítő a legkisebb téglalap, amely mindkét forrás téglalapot tartalmazza.

A Windows figyelmen kívül hagyja egy üres téglalap méretét; vagyis olyan téglalap, amelynek nincs magassága vagy szélessége.

Megjegyzés:

Mindkét téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalapok normalizálására.

példa

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

Kiszámítja a szélességet CRect úgy, hogy kivonja a bal értéket a jobb értékből.

int Width() const throw();

Visszaadott érték

A szélessége CRect.

Megjegyzések

A szélesség negatív lehet.

Megjegyzés:

A téglalapot normalizálni kell, vagy ez a függvény sikertelen lehet. A függvény meghívása előtt meghívhatja NormalizeRect a téglalap normalizálására.

példa

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

Lásd még

CPoint osztály
CSize osztály
RECT