Classe CRect

Simile a una struttura di Windows RECT .

Sintassi

class CRect : public tagRECT

Membri

Costruttori pubblici

Nome	Descrizione
CRect::CRect	Costruisce un oggetto CRect.

Metodi pubblici

Nome	Descrizione
CRect::BottomRight	Restituisce il punto inferiore destro di CRect.
CRect::CenterPoint	Restituisce il punto centrale di CRect.
CRect::CopyRect	Copia le dimensioni di un rettangolo di origine in CRect.
CRect::DeflateRect	Riduce la larghezza e l'altezza di CRect.
CRect::EqualRect	Determina se CRect è uguale al rettangolo specificato.
CRect::Height	Calcola l'altezza di CRect.
CRect::InflateRect	Aumenta la larghezza e l'altezza di CRect.
CRect::IntersectRect	Imposta CRect un valore uguale all'intersezione di due rettangoli.
CRect::IsRectEmpty	Determina se CRect è vuoto. CRect è vuoto se la larghezza e/o l'altezza sono 0.
CRect::IsRectNull	Determina se le topvariabili membro , bottomleft, e right sono tutte uguali a 0.
CRect::MoveToX	Passa CRect alla coordinata x specificata.
CRect::MoveToXY	Passa CRect alle coordinate x e y specificate.
CRect::MoveToY	Passa CRect alla coordinata y specificata.
CRect::NormalizeRect	Standardizza l'altezza e la larghezza di CRect.
CRect::OffsetRect	Sposta CRect in base agli offset specificati.
CRect::PtInRect	Determina se il punto specificato si trova all'interno CRectdi .
CRect::SetRect	Imposta le dimensioni di CRect.
CRect::SetRectEmpty	Imposta CRect su un rettangolo vuoto (tutte le coordinate uguali a 0).
CRect::Size	Calcola le dimensioni di CRect.
CRect::SubtractRect	Sottrae un rettangolo da un altro.
CRect::TopLeft	Restituisce il punto in alto a sinistra di CRect.
CRect::UnionRect	Imposta CRect uguale all'unione di due rettangoli.
CRect::Width	Calcola la larghezza di CRect.

Operatori pubblici

Nome	Descrizione
CRect::operator -	Sottrae gli offset specificati da CRect o deflate CRect e restituisce l'oggetto risultante CRect.
CRect::operator LPCRECT	Converte CRect in LPCRECT.
CRect::operator LPRECT	Converte CRect in LPRECT.
CRect::operator !=	Determina se CRect non è uguale a un rettangolo.
CRect::operator &	Crea l'intersezione di CRect e un rettangolo e restituisce l'oggetto risultante CRect.
CRect::operator &=	Imposta CRect uguale all'intersezione di CRect e a un rettangolo.
CRect::operator |	Crea l'unione di CRect e un rettangolo e restituisce l'oggetto risultante CRect.
CRect::operator |=	Imposta CRect uguale all'unione di CRect e a un rettangolo.
CRect::operator +	Aggiunge gli offset specificati a CRect o gonfia e restituisce CRect l'oggetto risultante CRect.
CRect::operator +=	Aggiunge gli offset specificati a CRect o aumenta CRect.
CRect::operator =	Copia le dimensioni di un rettangolo in CRect.
CRect::operator -=	Sottrae gli offset specificati da CRect o deflasce CRect.
CRect::operator ==	Determina se CRect è uguale a un rettangolo.

Osservazioni:

CRect include anche funzioni membro per modificare CRect gli oggetti e le strutture di Windows RECT .

Un CRect oggetto può essere passato come parametro di funzione ovunque sia possibile passare una RECT struttura, LPCRECTo LPRECT .

Contiene CRect variabili membro che definiscono i punti superiore sinistro e inferiore destro di un rettangolo.

Quando si specifica un oggetto CRect, è necessario prestare attenzione a crearlo in modo che venga normalizzato, in altre parole, in modo che il valore della coordinata sinistra sia minore di quello destro e quello superiore sia minore del basso. Ad esempio, un angolo superiore sinistro (10,10) e inferiore destro di (20,20) definisce un rettangolo normalizzato, ma un rettangolo in alto a sinistra (20,20) e inferiore destro di (10,10) definisce un rettangolo non normalizzato. Se il rettangolo non è normalizzato, molte CRect funzioni membro potrebbero restituire risultati non corretti. Per un elenco di queste funzioni, vedere CRect::NormalizeRect . Prima di chiamare una funzione che richiede rettangoli normalizzati, è possibile normalizzare i rettangoli non normalizzati chiamando la NormalizeRect funzione .

Prestare attenzione quando si modifica un CRect oggetto con le CDC::DPtoLP funzioni membro e CDC::LPtoDP . Se la modalità di mapping di un contesto di visualizzazione è tale che l'extent y sia negativo, come in MM_LOENGLISH, CDC::DPtoLP trasformerà in modo che la CRect parte superiore sia maggiore della parte inferiore. Le funzioni come Height e Size restituiscono quindi valori negativi per l'altezza dell'oggetto trasformato CRecte il rettangolo non verrà normalizzato.

Quando si usano operatori di CRect overload, il primo operando deve essere un CRect. Il secondo può essere una RECT struttura o un CRect oggetto .

Gerarchia di ereditarietà

tagRECT

CRect

Requisiti

Intestazione: atltypes.h

CRect::BottomRight

Le coordinate vengono restituite come riferimento a un CPoint oggetto contenuto in CRect.

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

Valore restituito

Coordinate dell'angolo inferiore destro del rettangolo.

Osservazioni:

È possibile usare questa funzione per ottenere o impostare l'angolo inferiore destro del rettangolo. Impostare l'angolo usando questa funzione sul lato sinistro dell'operatore di assegnazione.

Esempio

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

Calcola il punto centrale di CRect aggiungendo i valori sinistro e destro e dividendo per due e aggiungendo i valori superiore e inferiore e dividendo per due.

CPoint CenterPoint() const throw();

Valore restituito

Oggetto CPoint che rappresenta il punto centrale di CRect.

Esempio

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

Copia il lpSrcRect rettangolo in CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parametri

lpSrcRect
Punta alla struttura o CRect all'oggetto RECT da copiare.

Esempio

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

Costruisce un oggetto CRect.

CRect() throw();
CRect(int l, int t, int r, int b) throw();
CRect(const RECT& srcRect) throw();
CRect(LPCRECT lpSrcRect) throw();
CRect(POINT point, SIZE size) throw();
CRect(POINT topLeft, POINT bottomRight) throw();

Parametri

l
Specifica la posizione sinistra di CRect.

t
Specifica la parte superiore di CRect.

r
Specifica la posizione corretta di CRect.

b
Specifica la parte inferiore di CRect.

srcRect
Fa riferimento alla RECT struttura con le coordinate per CRect.

lpSrcRect
Punta alla RECT struttura con le coordinate per CRect.

point
Specifica il punto di origine per il rettangolo da costruire. Corrisponde all'angolo superiore sinistro.

size
Specifica lo spostamento dall'angolo superiore sinistro all'angolo inferiore destro del rettangolo da costruire.

topLeft
Specifica la posizione superiore sinistra di CRect.

bottomRight
Specifica la posizione inferiore destra di CRect.

Osservazioni:

Se non vengono specificati argomenti, lefti membri , top, e bottom vengono rightimpostati su 0.

I CRectcostruttori (const RECT&) e CRect(LPCRECT) eseguono un oggetto CopyRect. Gli altri costruttori inizializzano direttamente le variabili membro dell'oggetto.

Esempio

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

DeflateRectCRect sgonfia spostando i lati verso il centro.

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

Parametri

x
Specifica il numero di unità da sgonfiare i lati sinistro e destro di CRect.

y
Specifica il numero di unità da sgonfiare la parte superiore e inferiore di CRect.

size
Oggetto SIZE o CSize che specifica il numero di unità da deflare CRect. Il cx valore specifica il numero di unità da sgonfiare i lati sinistro e destro e il cy valore specifica il numero di unità da sgonfiare la parte superiore e inferiore.

lpRect
Punta a una RECT struttura o CRect che specifica il numero di unità da sgonfiare ogni lato.

l
Specifica il numero di unità da sgonfiare il lato sinistro di CRect.

t
Specifica il numero di unità da sgonfiare la parte superiore di CRect.

r
Specifica il numero di unità da sgonfiare il lato destro di CRect.

b
Specifica il numero di unità da sgonfiare la parte inferiore di CRect.

Osservazioni:

A tale scopo, DeflateRect aggiunge unità a sinistra e in alto e sottrae le unità dalla destra e dal basso. I parametri di DeflateRect sono valori firmati; i valori positivi deflate CRect e i valori negativi lo gonfiano.

I primi due overload sgonfiano entrambe le coppie di lati opposti di CRect in modo che la larghezza totale venga ridotta di due volte (o cx) e l'altezza totale viene ridotta di due volte x y (o cy). Gli altri due overload sgonfiano ogni lato indipendentemente CRect dagli altri.

Esempio

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

Determina se CRect è uguale al rettangolo specificato.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parametri

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene le coordinate dell'angolo superiore sinistro e inferiore destro di un rettangolo.

Valore restituito

Diverso da zero se i due rettangoli hanno gli stessi valori superiore, sinistro, inferiore e destro; in caso contrario, 0.

Esempio

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

Calcola l'altezza di CRect sottraendo il valore superiore dal valore inferiore.

int Height() const throw();

Valore restituito

Altezza di CRect.

Osservazioni:

Il valore risultante può essere negativo.

Esempio

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

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

CRect::InflateRect

InflateRect gonfia spostando CRect i lati lontano dal suo centro.

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

Parametri

x
Specifica il numero di unità da gonfiare i lati sinistro e destro di CRect.

y
Specifica il numero di unità da gonfiare nella parte superiore e inferiore di CRect.

size
Oggetto SIZE o CSize che specifica il numero di unità da gonfiare CRect. Il cx valore specifica il numero di unità da gonfiare i lati sinistro e destro e il cy valore specifica il numero di unità da gonfiare in alto e in basso.

lpRect
Punta a una RECT struttura o CRect che specifica il numero di unità da gonfiare ogni lato.

l
Specifica il numero di unità da gonfiare sul lato sinistro di CRect.

t
Specifica il numero di unità da gonfiare nella parte superiore di CRect.

r
Specifica il numero di unità da gonfiare sul lato destro di CRect.

b
Specifica il numero di unità da gonfiare nella parte inferiore di CRect.

Osservazioni:

A tale scopo, InflateRect sottrae le unità da sinistra e dall'alto e aggiunge unità a destra e in basso. I parametri di InflateRect sono valori con segno; i valori positivi gonfiano CRect e i valori negativi la deflazionano.

I primi due overload gonfiano entrambe le coppie di lati opposti di CRect in modo che la larghezza totale venga aumentata di due volte x (o cx) e l'altezza totale viene aumentata di due volte y (o cy). Gli altri due overload gonfiano ogni lato indipendentemente CRect dagli altri.

Esempio

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

Rende uguale CRect all'intersezione di due rettangoli esistenti.

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

Parametri

lpRect1
Punta a una struttura o CRect a un RECT oggetto che contiene un rettangolo di origine.

lpRect2
Punta a una struttura o CRect a un RECT oggetto che contiene un rettangolo di origine.

Valore restituito

Diverso da zero se l'intersezione non è vuota; 0 se l'intersezione è vuota.

Osservazioni:

L'intersezione è il rettangolo più grande contenuto in entrambi i rettangoli esistenti.

Esempio

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

Determina se CRect è vuoto.

BOOL IsRectEmpty() const throw();

Valore restituito

Diverso da zero se CRect è vuoto; 0 se CRect non è vuoto.

Osservazioni:

Un rettangolo è vuoto se la larghezza e/o l'altezza sono 0 o negative. Differisce da IsRectNull, che determina se tutte le coordinate del rettangolo sono zero.

Esempio

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

Determina se i valori superiore, sinistro, inferiore e destro di CRect sono tutti uguali a 0.

BOOL IsRectNull() const throw();

Valore restituito

Diverso da zero se i CRectvalori superiore, sinistro, inferiore e destro sono tutti uguali a 0; in caso contrario, 0.

Osservazioni:

Differisce da IsRectEmpty, che determina se il rettangolo è vuoto.

Esempio

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

Chiamare questa funzione per spostare il rettangolo nella coordinata x assoluta specificata da x.

void MoveToX(int x) throw();

Parametri

x
Coordinata x assoluta per l'angolo superiore sinistro del rettangolo.

Esempio

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

Chiamare questa funzione per spostare il rettangolo nelle coordinate x e y assolute specificate.

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

Parametri

x
Coordinata x assoluta per l'angolo superiore sinistro del rettangolo.

y
Coordinata y assoluta per l'angolo superiore sinistro del rettangolo.

point
Struttura POINT che specifica l'angolo superiore sinistro assoluto del rettangolo.

Esempio

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

Chiamare questa funzione per spostare il rettangolo nella coordinata y assoluta specificata da y.

void MoveToY(int y) throw();

Parametri

y
Coordinata y assoluta per l'angolo superiore sinistro del rettangolo.

Esempio

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

Normalizza in CRect modo che sia l'altezza che la larghezza siano positive.

void NormalizeRect() throw();

Osservazioni:

Il rettangolo viene normalizzato per il posizionamento del quarto quadrante, che Windows usa in genere per le coordinate. NormalizeRect confronta i valori superiore e inferiore e li scambia se la parte superiore è maggiore della parte inferiore. Analogamente, scambia i valori sinistro e destro se la sinistra è maggiore della destra. Questa funzione è utile quando si gestiscono diverse modalità di mapping e rettangoli invertiti.

Esempio

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

CRect::OffsetRect

Sposta CRect in base agli offset specificati.

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

Parametri

x
Specifica l'importo da spostare a sinistra o a destra. Deve essere negativo per spostarsi a sinistra.

y
Specifica l'importo da spostare verso l'alto o verso il basso. Deve essere negativo per alzarsi.

point
Contiene una struttura o CPoint un POINT oggetto che specifica entrambe le dimensioni in base alle quali spostarsi.

size
Contiene una struttura o CSize un SIZE oggetto che specifica entrambe le dimensioni in base alle quali spostarsi.

Osservazioni:

Sposta CRectx le unità lungo l'asse x e y le unità lungo l'asse y. I x parametri e y sono valori con segno, quindi CRect possono essere spostati verso sinistra o destra e verso l'alto o verso il basso.

Esempio

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 Converte un oggetto in CRect un oggetto LPCRECT.

operator LPCRECT() const throw();

Osservazioni:

Quando si usa questa funzione, non è necessario l'operatore address-of (&). Questo operatore verrà usato automaticamente quando si passa un CRect oggetto a una funzione che prevede un oggetto LPCRECT.

CRect::operator LPRECT

Converte CRect in LPRECT.

operator LPRECT() throw();

Osservazioni:

Quando si usa questa funzione, non è necessario l'operatore address-of (&). Questo operatore verrà usato automaticamente quando si passa un CRect oggetto a una funzione che prevede un oggetto LPRECT.

Esempio

Vedere l'esempio per CRect::operator LPCRECT.

CRect::operator =

srcRect Assegna a CRect.

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

Parametri

srcRect
Fa riferimento a un rettangolo di origine. Può essere un RECT oggetto o CRect.

Esempio

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

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

CRect::operator ==

Determina se rect è uguale a CRect confrontando le coordinate degli angoli superiore sinistro e inferiore destro.

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

Parametri

rect
Fa riferimento a un rettangolo di origine. Può essere un RECT oggetto o CRect.

Valore restituito

Diverso da zero se uguale; in caso contrario, 0.

Osservazioni:

Esempio

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

Determina se rect non è uguale a CRect confrontando le coordinate degli angoli superiore sinistro e inferiore destro.

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

Parametri

rect
Fa riferimento a un rettangolo di origine. Può essere un RECT oggetto o CRect.

Valore restituito

Diverso da zero se non uguale; in caso contrario, 0.

Osservazioni:

Esempio

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

I primi due overload vengono spostati CRect dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità di misura per spostare il rettangolo.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità di misura per spostare il rettangolo.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da gonfiare ogni lato di CRect.

Osservazioni:

I valori e y (o cx e cy) del x parametro vengono aggiunti a CRect.

Il terzo overload viene gonfiato in base CRect al numero di unità specificate in ogni membro del parametro.

Esempio

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

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

CRect::operator -=

I primi due overload vengono spostati CRect dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità di misura per spostare il rettangolo.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità di misura per spostare il rettangolo.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da sgonfiare ogni lato di CRect.

Osservazioni:

I valori e y (o cx e cy) del x parametro vengono sottratti da CRect.

Il terzo overload sgonfia CRect in base al numero di unità specificate in ogni membro del parametro. Si noti che questo overload funziona come DeflateRect.

Esempio

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

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

CRect::operator &=

Imposta CRect uguale all'intersezione di CRect e rect.

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

Parametri

rect
Contiene un RECT oggetto o CRect.

Osservazioni:

L'intersezione è il rettangolo più grande contenuto in entrambi i rettangoli.

Esempio

Vedere l'esempio per CRect::IntersectRect.

CRect::operator |=

Imposta CRect uguale all'unione di CRect e rect.

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

Parametri

rect
Contiene un CRect oggetto o RECT.

Osservazioni:

L'unione è il rettangolo più piccolo che contiene entrambi i rettangoli di origine.

Esempio

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 +

I primi due overload restituiscono un CRect oggetto uguale a CRect spostato dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità per spostare il valore restituito.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità per spostare il valore restituito.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da gonfiare ogni lato del valore restituito.

Valore restituito

Oggetto CRect risultante dallo spostamento o dall'aumento CRect in base al numero di unità specificate nel parametro .

Osservazioni:

I parametri e y (o cx e cy) del x parametro vengono aggiunti alla CRectposizione del parametro .

Il terzo overload restituisce un nuovo CRect oggetto uguale a gonfiato in base al CRect numero di unità specificate in ogni membro del parametro.

Esempio

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 -

I primi due overload restituiscono un CRect oggetto uguale a CRect spostato dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità per spostare il valore restituito.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità per spostare il valore restituito.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da sgonfiare ogni lato del valore restituito.

Valore restituito

Oggetto CRect risultante CRect dallo spostamento o dall'abbassamento in base al numero di unità specificate nel parametro .

Osservazioni:

I parametri e y (o cx e cy) del x parametro vengono sottratti dalla CRectposizione del parametro.

Il terzo overload restituisce un nuovo CRect oggetto uguale a deflato in base al CRect numero di unità specificate in ogni membro del parametro. Si noti che questo overload funziona come DeflateRect, non SubtractRect.

Esempio

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 &

Restituisce un oggetto CRect che rappresenta l'intersezione tra CRect e rect2.

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

Parametri

rect2
Contiene un RECT oggetto o CRect.

Valore restituito

Oggetto CRect che rappresenta l'intersezione di CRect e rect2.

Osservazioni:

L'intersezione è il rettangolo più grande contenuto in entrambi i rettangoli.

Esempio

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 |

Restituisce un oggetto CRect che rappresenta l'unione di CRect e rect2.

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

Parametri

rect2
Contiene un RECT oggetto o CRect.

Valore restituito

Oggetto CRect che rappresenta l'unione di CRect e rect2.

Osservazioni:

L'unione è il rettangolo più piccolo che contiene entrambi i rettangoli.

Esempio

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

Determina se il punto specificato si trova all'interno CRectdi .

BOOL PtInRect(POINT point) const throw();

Parametri

point
Contiene una struttura o CPoint un POINT oggetto .

Valore restituito

Diverso da zero se il punto si trova all'interno CRectdi ; in caso contrario, 0.

Osservazioni:

Un punto si trova all'interno se si trova sul lato sinistro o superiore o si trova all'interno CRect di tutti e quattro i lati. Un punto sul lato destro o inferiore si trova all'esterno CRectdi .

Esempio

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

Imposta le dimensioni di CRect sulle coordinate specificate.

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

Parametri

x1
Specifica la coordinata x dell'angolo superiore sinistro.

y1
Specifica la coordinata y dell'angolo superiore sinistro.

x2
Specifica la coordinata x dell'angolo inferiore destro.

y2
Specifica la coordinata y dell'angolo inferiore destro.

Esempio

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

CRect::SetRectEmpty

Crea CRect un rettangolo Null impostando tutte le coordinate su zero.

void SetRectEmpty() throw();

Esempio

CRect rect;
rect.SetRectEmpty();

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

CRect::SIZE

I cx membri e cy del valore restituito contengono l'altezza e la larghezza di CRect.

CSize Size() const throw();

Valore restituito

Oggetto CSize contenente le dimensioni di CRect.

Osservazioni:

L'altezza o la larghezza possono essere negative.

Esempio

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

CRect::SubtractRect

Rende le dimensioni dell'oggetto CRect uguale alla sottrazione di lpRectSrc2 da lpRectSrc1.

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

Parametri

lpRectSrc1
Punta alla struttura o CRect all'oggetto RECT da cui deve essere sottratto un rettangolo.

lpRectSrc2
Punta alla struttura o CRect all'oggetto RECT che deve essere sottratto dal rettangolo a cui punta il lpRectSrc1 parametro .

Valore restituito

Diverso da zero se la funzione ha esito positivo; in caso contrario, 0.

Osservazioni:

La sottrazione è il rettangolo più piccolo che contiene tutti i punti in lpRectScr1 che non si trovano nell'intersezione di lpRectScr1 e lpRectScr2.

Il rettangolo specificato da lpRectSrc1 sarà invariato se il rettangolo specificato da lpRectSrc2 non sovrappone completamente il rettangolo specificato da lpRectSrc1 in almeno una delle direzioni x o y.

Ad esempio, se lpRectSrc1 fossero (10,10, 100,100) e lpRectSrc2 fossero (50,50, 150,150), il rettangolo a cui lpRectSrc1 punta sarebbe invariato quando la funzione restituita. Se lpRectSrc1 fossero (10,10, 100,100) e lpRectSrc2 fossero (50,10, 150,150), tuttavia, il rettangolo a lpRectSrc1 cui puntava conterrà le coordinate (10,10, 50,100) quando la funzione restituita.

SubtractRect non è uguale all'operatore - né operator -=. Nessuno di questi operatori chiama SubtractRectmai .

Esempio

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

Le coordinate vengono restituite come riferimento a un CPoint oggetto contenuto in CRect.

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

Valore restituito

Coordinate dell'angolo superiore sinistro del rettangolo.

Osservazioni:

È possibile usare questa funzione per ottenere o impostare l'angolo superiore sinistro del rettangolo. Impostare l'angolo usando questa funzione sul lato sinistro dell'operatore di assegnazione.

Esempio

Vedere l'esempio per CRect::CenterPoint.

CRect::UnionRect

Rende le dimensioni di CRect uguale all'unione dei due rettangoli di origine.

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

Parametri

lpRect1
Punta a un RECT oggetto o CRect che contiene un rettangolo di origine.

lpRect2
Punta a un RECT oggetto o CRect che contiene un rettangolo di origine.

Valore restituito

Diverso da zero se l'unione non è vuota; 0 se l'unione è vuota.

Osservazioni:

L'unione è il rettangolo più piccolo che contiene entrambi i rettangoli di origine.

Windows ignora le dimensioni di un rettangolo vuoto; ovvero un rettangolo senza altezza o senza larghezza.

Esempio

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

Calcola la larghezza di CRect sottraendo il valore sinistro dal valore destro.

int Width() const throw();

Valore restituito

Larghezza di CRect.

Osservazioni:

La larghezza può essere negativa.

Esempio

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

Vedi anche

CPoint Classe
CSize Classe
RECT