CRect-klass

Liknar en Windows-struktur RECT .

Syntax

class CRect : public tagRECT

Medlemmar

Offentliga konstruktorer

Offentliga metoder

Offentliga operatörer

Anmärkningar

CRect innehåller även medlemsfunktioner för att manipulera CRect objekt och Windows-strukturer RECT .

Ett CRect objekt kan skickas som en funktionsparameter varhelst en RECT struktur, LPCRECTeller LPRECT kan skickas.

En CRect innehåller medlemsvariabler som definierar de övre vänstra och nedre högra punkterna i en rektangel.

När du anger en CRectmåste du vara noga med att konstruera den så att den normaliseras , med andra ord så att värdet för den vänstra koordinaten är mindre än höger och att den övre delen är mindre än botten. Till exempel definierar en normaliserad rektangel överst till vänster (10,10) och längst ned till höger (20,20) en normaliserad rektangel men en övre vänstra del av (20,20) och längst ned till höger på (10,10) definierar en icke-normaliserad rektangel. Om rektangeln inte normaliseras kan många CRect medlemsfunktioner returnera felaktiga resultat. (Se CRect::NormalizeRect en lista över dessa funktioner.) Innan du anropar en funktion som kräver normaliserade rektanglar kan du normalisera icke-normaliserade rektanglar genom att anropa NormalizeRect funktionen.

Var försiktig när du manipulerar en CRect med medlemsfunktionerna CDC::DPtoLP och CDC::LPtoDP . Om mappningsläget för en visningskontext är sådant att y-omfattningen är negativ, som i MM_LOENGLISH, CDC::DPtoLP omvandlas CRect den så att dess överkant är större än botten. Funktioner som Height och Size returnerar sedan negativa värden för höjden på transformerade CRect, och rektangeln kommer inte att normaliseras.

När du använder överbelastade CRect operatorer måste den första operanden vara en CRect. Den andra kan vara antingen en RECT struktur eller ett CRect objekt.

Arvshierarki

tagRECT

CRect

Kravspecifikation

rubrik:atltypes.h

CRect::BottomRight

Koordinaterna returneras som en referens till ett CPoint objekt som finns i CRect.

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

Returvärde

Koordinaterna för rektangelns nedre högra hörn.

Anmärkningar

Du kan använda den här funktionen för att antingen hämta eller ange det nedre högra hörnet i rektangeln. Ange hörnet med hjälp av den här funktionen till vänster om tilldelningsoperatorn.

Exempel

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

Beräknar mittpunkten CRect för genom att lägga till värdena till vänster och höger och dividera med två, lägga till de övre och nedre värdena och dividera med två.

CPoint CenterPoint() const throw();

Returvärde

Ett CPoint objekt som är mittpunkten för CRect.

Exempel

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

Kopierar lpSrcRect rektangeln till CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parameterar

lpSrcRect
Pekar på den RECT struktur eller CRect det objekt som ska kopieras.

Exempel

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

Konstruerar ett CRect 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();

Parameterar

l
Anger den vänstra positionen för CRect.

t
Anger överst CRecti .

r
Anger rätt position för CRect.

b
Anger botten av CRect.

srcRect
Refererar till RECT strukturen med koordinaterna för CRect.

lpSrcRect
Pekar på RECT strukturen med koordinaterna för CRect.

point
Anger ursprungspunkten för rektangeln som ska konstrueras. Motsvarar det övre vänstra hörnet.

size
Anger förskjutningen från det övre vänstra hörnet till det nedre högra hörnet av rektangeln som ska konstrueras.

topLeft
Anger den övre vänstra positionen för CRect.

bottomRight
Anger den nedre högra positionen för CRect.

Anmärkningar

Om inga argument anges anges , lefttop, rightoch bottom medlemmar till 0.

Konstruktorerna CRect(const RECT&) och CRect(LPCRECT) utför en CopyRect. De andra konstruktorerna initierar medlemsvariablerna för objektet direkt.

Exempel

// 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 deflaterar CRect genom att flytta dess sidor mot dess mitt.

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

Parameterar

x
Anger antalet enheter som ska deflatera vänster och höger sida av CRect.

y
Anger antalet enheter som ska deflatera den övre och nedre delen av CRect.

size
En SIZE eller CSize som anger antalet enheter som ska deflatera CRect. Värdet cx anger antalet enheter som ska deflatera vänster och höger sida och cy värdet anger antalet enheter som ska deflatera den övre och nedre delen.

lpRect
Pekar på en RECT struktur eller CRect som anger antalet enheter som ska deflatera varje sida.

l
Anger antalet enheter som ska deflatera vänster sida av CRect.

t
Anger antalet enheter som ska deflatera överst i CRect.

r
Anger antalet enheter som ska deflatera höger sida av CRect.

b
Anger antalet enheter som ska deflatera botten av CRect.

Anmärkningar

Det gör du genom DeflateRect att lägga till enheter till vänster och överst och subtrahera enheter från höger och nederkant. Parametrarna DeflateRect för är signerade värden, positiva värden deflatera CRect och negativa värden blåser upp det.

De två första överlagringarna deflaterar båda paren av motsatta sidor så CRect att dess totala bredd minskas med två gånger x (eller cx) och dess totala höjd minskas med två gånger y (eller cy). De andra två överlagringarna deflaterar varje sida av CRect oberoende av de andra.

Exempel

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

Avgör om CRect är lika med den angivna rektangeln.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parameterar

lpRect
Pekar på en struktur eller CRect ett RECT objekt som innehåller koordinaterna i det övre vänstra och nedre högra hörnet i en rektangel.

Returvärde

Nonzero om de två rektanglarna har samma värden överst, vänster, nederkant och höger; annars 0.

Exempel

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

Beräknar höjden på CRect genom att subtrahera det översta värdet från det nedre värdet.

int Height() const throw();

Returvärde

Höjden på CRect.

Anmärkningar

Det resulterande värdet kan vara negativt.

Exempel

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

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

CRect::InflateRect

InflateRect blåses CRect upp genom att flytta sidorna bort från mitten.

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

Parameterar

x
Anger antalet enheter som ska blåsa upp vänster och höger sida av CRect.

y
Anger antalet enheter som ska blåsas upp och ned i CRect.

size
En SIZE eller CSize som anger antalet enheter som ska blåsas upp CRect. Värdet cx anger antalet enheter som ska blåsa upp vänster och höger sida och cy värdet anger antalet enheter som ska blåsas upp överst och ned.

lpRect
Pekar på en RECT struktur eller CRect som anger antalet enheter som ska blåsas upp på varje sida.

l
Anger antalet enheter som ska blåsas upp till vänster i CRect.

t
Anger antalet enheter som ska blåsas upp överst i CRect.

r
Anger antalet enheter som ska blåsas upp på höger sida av CRect.

b
Anger antalet enheter som ska blåsas upp längst ned i CRect.

Anmärkningar

Det gör InflateRect du genom att subtrahera enheter från vänster och överkant och lägga till enheter till höger och nederkant. Parametrarna InflateRect för är signerade värden, positiva värden blåses upp CRect och negativa värden deflatera det.

De två första överlagringarna blåser upp båda paren av motsatta sidor CRect så att dess totala bredd ökas med två gånger x (eller cx) och dess totala höjd ökas med två gånger y (eller cy). De andra två överlagringarna blåser upp varje sida av CRect oberoende av de andra.

Exempel

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

Gör en CRect lika med skärningspunkten mellan två befintliga rektanglar.

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

Parameterar

lpRect1
Pekar på en struktur eller CRect ett RECT objekt som innehåller en källrektangel.

lpRect2
Pekar på en struktur eller CRect ett RECT objekt som innehåller en källrektangel.

Returvärde

Nonzero om skärningspunkten inte är tom; 0 om skärningspunkten är tom.

Anmärkningar

Skärningspunkten är den största rektangel som finns i båda befintliga rektanglar.

Exempel

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

Avgör om CRect är tomt.

BOOL IsRectEmpty() const throw();

Returvärde

Nonzero om CRect är tom; 0 om CRect den inte är tom.

Anmärkningar

En rektangel är tom om bredden och/eller höjden är 0 eller negativ. Skiljer sig från IsRectNull, som avgör om alla koordinater för rektangeln är noll.

Exempel

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

Avgör om värdena CRect för överkant, vänster, nederkant och höger är lika med 0.

BOOL IsRectNull() const throw();

Returvärde

Nonzero om CRectvärdena för överkant, vänster, nederkant och höger är lika med 0, annars 0.

Anmärkningar

Skiljer sig från IsRectEmpty, som avgör om rektangeln är tom.

Exempel

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

Anropa den här funktionen för att flytta rektangeln till den absoluta x-koordinat som anges av x.

void MoveToX(int x) throw();

Parameterar

x
Den absoluta x-koordinaten för det övre vänstra hörnet i rektangeln.

Exempel

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

Anropa den här funktionen för att flytta rektangeln till de absoluta x- och y-koordinaterna som angetts.

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

Parameterar

x
Den absoluta x-koordinaten för det övre vänstra hörnet i rektangeln.

y
Den absoluta y-koordinaten för det övre vänstra hörnet i rektangeln.

point
En POINT struktur som anger det absoluta övre vänstra hörnet i rektangeln.

Exempel

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

Anropa den här funktionen för att flytta rektangeln till den absoluta y-koordinat som anges av y.

void MoveToY(int y) throw();

Parameterar

y
Den absoluta y-koordinaten för det övre vänstra hörnet i rektangeln.

Exempel

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

Normaliserar CRect så att både höjd och bredd är positiva.

void NormalizeRect() throw();

Anmärkningar

Rektangeln normaliseras för fjärde kvadrantpositionering, som Windows vanligtvis använder för koordinater. NormalizeRect jämför de översta och nedre värdena och byter ut dem om den övre delen är större än botten. På samma sätt växlar den vänster- och högervärdena om vänster är större än höger. Den här funktionen är användbar när du hanterar olika mappningslägen och inverterade rektanglar.

Exempel

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

CRect::OffsetRect

Flyttar efter CRect angivna förskjutningar.

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

Parameterar

x
Anger hur mycket som ska flyttas åt vänster eller höger. Det måste vara negativt att flytta åt vänster.

y
Anger hur mycket som ska flyttas uppåt eller nedåt. Det måste vara negativt att flytta upp.

point
Innehåller en struktur eller CPoint ett POINT objekt som anger båda dimensionerna som ska flyttas.

size
Innehåller en struktur eller CSize ett SIZE objekt som anger båda dimensionerna som ska flyttas.

Anmärkningar

Flyttar CRectx enheter längs x-axeln och y enheterna längs y-axeln. Parametrarna x och y är signerade värden, så CRect kan flyttas åt vänster eller höger och uppåt eller nedåt.

Exempel

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

Konverterar en CRect till en LPCRECT.

operator LPCRECT() const throw();

Anmärkningar

När du använder den här funktionen behöver du inte adressoperatorn (&). Den här operatorn används automatiskt när du skickar ett CRect objekt till en funktion som förväntar sig en LPCRECT.

CRect::operator LPRECT

Konverterar en CRect till en LPRECT.

operator LPRECT() throw();

Anmärkningar

När du använder den här funktionen behöver du inte adressoperatorn (&). Den här operatorn används automatiskt när du skickar ett CRect objekt till en funktion som förväntar sig en LPRECT.

Exempel

Se exemplet för CRect::operator LPCRECT.

CRect::operator =

Tilldelar srcRect till CRect.

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

Parameterar

srcRect
Refererar till en källrektangel. Kan vara en RECT eller CRect.

Exempel

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

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

CRect::operator ==

Avgör om rect är lika med genom att CRect jämföra koordinaterna för deras övre vänstra och nedre högra hörn.

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

Parameterar

rect
Refererar till en källrektangel. Kan vara en RECT eller CRect.

Returvärde

Nonzero om lika; annars 0.

Anmärkningar

Exempel

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

Avgör om rect inte är lika med genom att CRect jämföra koordinaterna för deras övre vänstra och nedre högra hörn.

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

Parameterar

rect
Refererar till en källrektangel. Kan vara en RECT eller CRect.

Returvärde

Nonzero om inte lika med; annars 0.

Anmärkningar

Exempel

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

De två första överlagringarna flyttas CRect med de angivna förskjutningarna.

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

Parameterar

point
En POINT struktur eller CPoint ett objekt som anger antalet enheter som ska flyttas i rektangeln.

size
En SIZE struktur eller CSize ett objekt som anger antalet enheter som ska flyttas i rektangeln.

lpRect
Pekar på en struktur eller CRect ett RECT objekt som innehåller antalet enheter som ska blåsas upp på varje sida av CRect.

Anmärkningar

Parameterns x och y (eller cx ) cyvärden läggs till i CRect.

Den tredje överlagringen blåses CRect upp av antalet enheter som anges i varje medlem i parametern.

Exempel

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

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

CRect::operator -=

De två första överlagringarna flyttas CRect med de angivna förskjutningarna.

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

Parameterar

point
En POINT struktur eller CPoint ett objekt som anger antalet enheter som ska flyttas i rektangeln.

size
En SIZE struktur eller CSize ett objekt som anger antalet enheter som ska flyttas i rektangeln.

lpRect
Pekar på en struktur eller CRect ett RECT objekt som innehåller antalet enheter som ska deflatera varje sida av CRect.

Anmärkningar

Parameterns x och y (eller cx och cy) värden subtraheras från CRect.

Den tredje överlagringen deflaterar CRect med antalet enheter som anges i varje medlem i parametern. Observera att den här överlagringen fungerar som DeflateRect.

Exempel

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

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

CRect::operator &=

Uppsättningar CRect som är lika med skärningspunkten CRect för och rect.

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

Parameterar

rect
Innehåller en RECT eller CRect.

Anmärkningar

Skärningspunkten är den största rektangel som finns i båda rektanglarna.

Exempel

Se exemplet för CRect::IntersectRect.

CRect::operator |=

Uppsättningar CRect som är lika med union av CRect och rect.

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

Parameterar

rect
Innehåller en CRect eller RECT.

Anmärkningar

Unionen är den minsta rektangel som innehåller båda källrektanglarna.

Exempel

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 +

De två första överlagringarna returnerar ett CRect objekt som är lika med förskjutet CRect av de angivna förskjutningarna.

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

Parameterar

point
En POINT struktur eller CPoint ett objekt som anger antalet enheter som ska flytta returvärdet.

size
En SIZE struktur eller CSize ett objekt som anger antalet enheter som ska flytta returvärdet.

lpRect
Pekar på en struktur eller CRect ett RECT objekt som innehåller antalet enheter som ska blåsa upp varje sida av returvärdet.

Returvärde

Resultatet CRect av att flytta eller blåsa CRect upp med det antal enheter som anges i parametern.

Anmärkningar

Parameterparametrarna x och y (eller cx ) cyläggs till i CRectpositionen .

Den tredje överlagringen returnerar en ny CRect som är lika CRect med uppblåst med antalet enheter som anges i varje medlem i parametern.

Exempel

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 -

De två första överlagringarna returnerar ett CRect objekt som är lika med förskjutet CRect av de angivna förskjutningarna.

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

Parameterar

point
En POINT struktur eller CPoint ett objekt som anger antalet enheter som ska flytta returvärdet.

size
En SIZE struktur eller CSize ett objekt som anger antalet enheter som ska flytta returvärdet.

lpRect
Pekar på en struktur eller CRect ett RECT objekt som innehåller antalet enheter som ska deflatera varje sida av returvärdet.

Returvärde

Resultatet CRect av att flytta eller deflatera CRect med det antal enheter som anges i parametern.

Anmärkningar

Parameterparametrarna x och y (eller cx ) cysubtraheras från CRect's position.

Den tredje överlagringen returnerar en ny CRect som är lika CRect med deflaterad med antalet enheter som anges i varje medlem i parametern. Observera att den här överlagringen fungerar som DeflateRect, inte SubtractRect.

Exempel

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 &

Returnerar en CRect som är skärningspunkten CRect för och rekt2.

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

Parameterar

rect2
Innehåller en RECT eller CRect.

Returvärde

En CRect som är skärningspunkten för CRect och rect2.

Anmärkningar

Skärningspunkten är den största rektangel som finns i båda rektanglarna.

Exempel

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 |

Returnerar en CRect som är en union av CRect och rect2.

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

Parameterar

rect2
Innehåller en RECT eller CRect.

Returvärde

A CRect som är unionen av CRect och rect2.

Anmärkningar

Unionen är den minsta rektangel som innehåller båda rektanglarna.

Exempel

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

Avgör om den angivna punkten ligger inom CRect.

BOOL PtInRect(POINT point) const throw();

Parameterar

point
Innehåller en struktur eller CPoint ett POINT objekt.

Returvärde

Nonzero om punkten ligger inom CRect; annars 0.

Anmärkningar

En punkt ligger inom CRect om den ligger till vänster eller överst eller ligger inom alla fyra sidorna. En punkt till höger eller längst ned är utanför CRect.

Exempel

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

Anger dimensionerna CRect för till de angivna koordinaterna.

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

Parameterar

x1
Anger x-koordinaten för det övre vänstra hörnet.

y1
Anger y-koordinaten för det övre vänstra hörnet.

x2
Anger x-koordinaten för det nedre högra hörnet.

y2
Anger y-koordinaten för det nedre högra hörnet.

Exempel

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

CRect::SetRectEmpty

Gör CRect en null-rektangel genom att ange alla koordinater till noll.

void SetRectEmpty() throw();

Exempel

CRect rect;
rect.SetRectEmpty();

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

CRect::SIZE

Och-medlemmarna cxcy i returvärdet innehåller höjden och bredden på CRect.

CSize Size() const throw();

Returvärde

Ett CSize objekt som innehåller storleken på CRect.

Anmärkningar

Antingen kan höjden eller bredden vara negativ.

Exempel

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

CRect::SubtractRect

Gör dimensionerna för CRect lika med subtraktionen för lpRectSrc2 från lpRectSrc1.

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

Parameterar

lpRectSrc1
Pekar på den RECT struktur eller CRect det objekt som en rektangel ska subtraheras från.

lpRectSrc2
Pekar på den RECT struktur eller CRect det objekt som ska subtraheras från den rektangel som parametern pekar på lpRectSrc1 .

Returvärde

Nonzero om funktionen lyckas; annars 0.

Anmärkningar

Subtraktionen är den minsta rektangel som innehåller alla punkter i lpRectScr1 som inte finns i skärningspunkten för lpRectScr1 och lpRectScr2.

Rektangeln som anges av lpRectSrc1 ändras inte om rektangeln som anges av lpRectSrc2 inte helt överlappar rektangeln som anges av lpRectSrc1 i minst en av x- eller y-riktningarna.

Om det till exempel lpRectSrc1 var (10 10, 100 100) och lpRectSrc2 var (50,50, 150 150) skulle rektangeln som pekas på av lpRectSrc1 vara oförändrad när funktionen returnerades. Om lpRectSrc1 var (10,10, 100,100) och lpRectSrc2 var (50,10, 150,150), skulle dock rektangeln som pekas på av lpRectSrc1 innehålla koordinaterna (10,10, 50,100) när funktionen returnerades.

SubtractRect är inte samma som operatorn - eller operatorn -=. Ingen av dessa operatorer anropar SubtractRectnågonsin .

Exempel

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

Koordinaterna returneras som en referens till ett CPoint objekt som finns i CRect.

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

Returvärde

Koordinaterna för det övre vänstra hörnet i rektangeln.

Anmärkningar

Du kan använda den här funktionen för att antingen hämta eller ange det övre vänstra hörnet i rektangeln. Ange hörnet med hjälp av den här funktionen till vänster om tilldelningsoperatorn.

Exempel

Se exemplet för CRect::CenterPoint.

CRect::UnionRect

Gör dimensionerna CRect lika med unionen för de två källrektanglarna.

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

Parameterar

lpRect1
Pekar på en RECT eller CRect som innehåller en källrektangel.

lpRect2
Pekar på en RECT eller CRect som innehåller en källrektangel.

Returvärde

Nonzero om facket inte är tomt; 0 om facket är tomt.

Anmärkningar

Unionen är den minsta rektangel som innehåller båda källrektanglarna.

Windows ignorerar dimensionerna för en tom rektangel. en rektangel som inte har någon höjd eller ingen bredd.

Exempel

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

Beräknar bredden CRect på genom att subtrahera det vänstra värdet från det högra värdet.

int Width() const throw();

Returvärde

Bredden på CRect.

Anmärkningar

Bredden kan vara negativ.

Exempel

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

Se även

CPoint klass
CSize klass
RECT