La classe CRect

Similaire à une structure Windows RECT .

Syntaxe

class CRect : public tagRECT

Membres

Constructeurs publics

Nom	Description
CRect::CRect	Construit un objet CRect.

Méthodes publiques

Nom	Description
CRect::BottomRight	Retourne le point inférieur droit de CRect.
CRect::CenterPoint	Retourne le point central de CRect.
CRect::CopyRect	Copie les dimensions d’un rectangle source dans CRect.
CRect::DeflateRect	Diminue la largeur et la hauteur de CRect.
CRect::EqualRect	Détermine s’il CRect est égal au rectangle donné.
CRect::Height	Calcule la hauteur de CRect.
CRect::InflateRect	Augmente la largeur et la hauteur de CRect.
CRect::IntersectRect	Définit CRect l’intersection de deux rectangles.
CRect::IsRectEmpty	Détermine s’il CRect est vide. CRect est vide si la largeur et/ou la hauteur sont 0.
CRect::IsRectNull	Détermine si les topvariables , , leftbottomet right membres sont toutes égales à 0.
CRect::MoveToX	Se déplace CRect vers la coordonnée x spécifiée.
CRect::MoveToXY	Se déplace CRect vers les coordonnées x et y spécifiées.
CRect::MoveToY	Se déplace CRect vers la coordonnée y spécifiée.
CRect::NormalizeRect	Normalise la hauteur et la largeur de CRect.
CRect::OffsetRect	Déplace CRect par les décalages spécifiés.
CRect::PtInRect	Détermine si le point spécifié se trouve dans CRect.
CRect::SetRect	Définit les dimensions de CRect.
CRect::SetRectEmpty	Définit CRect sur un rectangle vide (toutes les coordonnées égales à 0).
CRect::Size	Calcule la taille de CRect.
CRect::SubtractRect	Soustrait un rectangle d’un autre.
CRect::TopLeft	Retourne le point supérieur gauche de CRect.
CRect::UnionRect	Définit CRect la valeur égale à l’union de deux rectangles.
CRect::Width	Calcule la largeur de CRect.

Opérateurs publics

Nom	Description
CRect::operator -	Soustrait les décalages donnés ou CRect défle CRect et retourne le résultat CRect.
CRect::operator LPCRECT	Convertit CRect en LPCRECT.
CRect::operator LPRECT	Convertit CRect en LPRECT.
CRect::operator !=	Détermine s’il CRect n’est pas égal à un rectangle.
CRect::operator &	Crée l’intersection entre CRect et un rectangle et retourne le résultat CRect.
CRect::operator &=	Définit CRect la valeur égale à l’intersection d’un rectangle et d’un CRect rectangle.
CRect::operator |	Crée l’union d’un CRect rectangle et retourne le résultat CRect.
CRect::operator |=	Définit CRect la valeur égale à l’union d’un CRect rectangle et à un rectangle.
CRect::operator +	Ajoute les décalages donnés CRect à CRect ou gonfle et retourne le résultat CRect.
CRect::operator +=	Ajoute les décalages spécifiés à CRect ou gonfle CRect.
CRect::operator =	Copie les dimensions d’un rectangle dans CRect.
CRect::operator -=	Soustrait les décalages spécifiés à partir ou CRect déflates CRect.
CRect::operator ==	Détermine s’il CRect est égal à un rectangle.

Notes

CRect inclut également des fonctions membres pour manipuler des CRect objets et des structures Windows RECT .

Un CRect objet peut être passé en tant que paramètre de fonction où une RECT structure, LPCRECTou LPRECT peut être passée.

Un CRect contient des variables membres qui définissent les points supérieur gauche et inférieur droit d’un rectangle.

Lorsque vous spécifiez un CRect, vous devez être prudent de le construire afin qu’il soit normalisé , en d’autres termes, de sorte que la valeur de la coordonnée gauche est inférieure à la droite et que le haut est inférieur au bas. Par exemple, un rectangle normalisé (10 10 10) et le bas à droite de (20 20) définit un rectangle normalisé, mais un rectangle en haut à gauche de (20 20) et en bas à droite de (10 10) définit un rectangle non normalisé. Si le rectangle n’est pas normalisé, de nombreuses CRect fonctions membres peuvent retourner des résultats incorrects. (Consultez CRect::NormalizeRect la liste de ces fonctions.) Avant d’appeler une fonction qui nécessite des rectangles normalisés, vous pouvez normaliser les rectangles non normalisés en appelant la NormalizeRect fonction.

Soyez prudent lors de la manipulation d’un CRect avec les fonctions membres et CDC::LPtoDP les CDC::DPtoLP fonctions membres. Si le mode de mappage d’un contexte d’affichage est tel que l’étendue y est négative, comme dans MM_LOENGLISHle cas présent, CDC::DPtoLP transformera la CRect valeur de sorte que son sommet soit supérieur au bas. Les fonctions telles que Height et Size retournent ensuite des valeurs négatives pour la hauteur de la transformation CRect, et le rectangle sera non normalisé.

Lorsque vous utilisez des opérateurs surchargés CRect , le premier opérande doit être un CRect; le second peut être une RECT structure ou un CRect objet.

Hiérarchie d'héritage

tagRECT

CRect

Spécifications

En-tête : atltypes.h

CRect::BottomRight

Les coordonnées sont retournées sous forme de référence à un CPoint objet contenu dans CRect.

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

Valeur de retour

Coordonnées du coin inférieur droit du rectangle.

Notes

Vous pouvez utiliser cette fonction pour obtenir ou définir le coin inférieur droit du rectangle. Définissez l’angle à l’aide de cette fonction sur le côté gauche de l’opérateur d’affectation.

Exemple

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

Calcule le point central de l’ajout des CRect valeurs de gauche et de droite et de la division par deux, et l’ajout des valeurs supérieures et inférieures et la division par deux.

CPoint CenterPoint() const throw();

Valeur de retour

Objet CPoint qui est le point central de CRect.

Exemple

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

Copie le lpSrcRect rectangle dans CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Paramètres

lpSrcRect
Pointe vers la structure ou CRect l’objet RECT à copier.

Exemple

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

Construit un objet 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();

Paramètres

l
Spécifie la position gauche de CRect.

t
Spécifie le haut de CRect.

r
Spécifie la position droite de CRect.

b
Spécifie le bas de CRect.

srcRect
Fait référence à la RECT structure avec les coordonnées pour CRect.

lpSrcRect
Pointe vers la RECT structure avec les coordonnées pour CRect.

point
Spécifie le point d’origine du rectangle à construire. Correspond au coin supérieur gauche.

size
Spécifie le déplacement du coin supérieur gauche vers le coin inférieur droit du rectangle à construire.

topLeft
Spécifie la position supérieure gauche de CRect.

bottomRight
Spécifie la position inférieure droite de CRect.

Notes

Si aucun argument n’est donné, left, top, rightet bottom que les membres sont définis sur 0.

Les CRectconstructeurs () et CRect(const RECT&LPCRECT) effectuent un CopyRect. Les autres constructeurs initialisent directement les variables membres de l’objet.

Exemple

// 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 défle CRect en déplaçant ses côtés vers son centre.

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ètres

x
Spécifie le nombre d’unités à déflater les côtés gauche et droit de CRect.

y
Spécifie le nombre d’unités à déflater le haut et le bas de CRect.

size
Ou SIZE qui spécifie le nombre d’unités à déflater CRect.CSize La cx valeur spécifie le nombre d’unités à déflater les côtés gauche et droit, et la cy valeur spécifie le nombre d’unités à déflater le haut et le bas.

lpRect
Pointe vers une RECT structure ou CRect qui spécifie le nombre d’unités à déflater chaque côté.

l
Spécifie le nombre d’unités à déflater sur le côté gauche de CRect.

t
Spécifie le nombre d’unités à déflater en haut de CRect.

r
Spécifie le nombre d’unités à déflater sur le côté droit de CRect.

b
Spécifie le nombre d’unités à déflater en bas de CRect.

Notes

Pour ce faire, DeflateRect ajoute des unités à gauche et en haut et soustrait des unités de la droite et du bas. Les paramètres des DeflateRect valeurs signées ; les valeurs positives déflatent CRect et les valeurs négatives l’gonflent.

Les deux premières surcharges déflatent les deux paires de côtés opposés de CRect sorte que sa largeur totale soit réduite de deux fois x (ou cx) et sa hauteur totale est réduite de deux fois y (ou cy). Les deux autres surcharges déflatent chaque côté de CRect indépendamment des autres.

Exemple

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

Détermine s’il CRect est égal au rectangle donné.

BOOL EqualRect(LPCRECT lpRect) const throw();

Paramètres

lpRect
Pointe vers une structure ou CRect un RECT objet qui contient les coordonnées d’angle supérieur gauche et inférieur droit d’un rectangle.

Valeur de retour

Différent de zéro si les deux rectangles ont les mêmes valeurs supérieures, gauche, inférieure et droite ; sinon 0.

Exemple

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

Calcule la hauteur en CRect soustrayant la valeur supérieure de la valeur inférieure.

int Height() const throw();

Valeur de retour

Hauteur de CRect.

Notes

La valeur résultante peut être négative.

Exemple

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

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

CRect::InflateRect

InflateRectCRect gonfle en déplaçant ses côtés loin de son centre.

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ètres

x
Spécifie le nombre d’unités à gonfler les côtés gauche et droit de CRect.

y
Spécifie le nombre d’unités à gonfler le haut et le bas de CRect.

size
Ou SIZE qui spécifie le nombre d’unités à gonfler CRect.CSize La cx valeur spécifie le nombre d’unités à gonfler les côtés gauche et droit et la cy valeur spécifie le nombre d’unités pour gonfler le haut et le bas.

lpRect
Pointe vers une RECT structure ou CRect qui spécifie le nombre d’unités à gonfler chaque côté.

l
Spécifie le nombre d’unités à gonfler sur le côté gauche de CRect.

t
Spécifie le nombre d’unités à gonfler le haut de CRect.

r
Spécifie le nombre d’unités à gonfler le côté droit de CRect.

b
Spécifie le nombre d’unités pour gonfler le bas de CRect.

Notes

Pour ce faire, InflateRect soustrait les unités de la gauche et du haut et ajoute des unités à droite et en bas. Les paramètres des InflateRect valeurs signées ; les valeurs positives gonflent CRect et les valeurs négatives la déflatent.

Les deux premières surcharges gonflent les deux paires de côtés opposés afin CRect que sa largeur totale soit augmentée de deux fois x (ou cx) et sa hauteur totale est augmentée de deux fois y (ou cy). Les deux autres surcharges gonflent chaque côté de CRect indépendamment des autres.

Exemple

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

Rend égal CRect à l’intersection de deux rectangles existants.

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

Paramètres

lpRect1
Pointe vers une structure ou CRect un RECT objet qui contient un rectangle source.

lpRect2
Pointe vers une structure ou CRect un RECT objet qui contient un rectangle source.

Valeur de retour

Différent de zéro si l’intersection n’est pas vide ; 0 si l’intersection est vide.

Notes

L’intersection est le plus grand rectangle contenu dans les deux rectangles existants.

Exemple

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

Détermine s’il CRect est vide.

BOOL IsRectEmpty() const throw();

Valeur de retour

Différent de zéro s’il CRect est vide ; 0 s’il CRect n’est pas vide.

Notes

Un rectangle est vide si la largeur et/ou la hauteur sont 0 ou négatives. Diffère de IsRectNull, qui détermine si toutes les coordonnées du rectangle sont égales à zéro.

Exemple

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

Détermine si les valeurs supérieures, gauche, inférieure et droite sont CRect toutes égales à 0.

BOOL IsRectNull() const throw();

Valeur de retour

Différent de zéro si CRectles valeurs supérieures, gauche, inférieure et droite sont toutes égales à 0 ; sinon, 0.

Notes

Diffère de IsRectEmpty, qui détermine si le rectangle est vide.

Exemple

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

Appelez cette fonction pour déplacer le rectangle vers la coordonnée x absolue spécifiée par x.

void MoveToX(int x) throw();

Paramètres

x
Coordonnée x absolue pour l’angle supérieur gauche du rectangle.

Exemple

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

Appelez cette fonction pour déplacer le rectangle vers les coordonnées x et y absolues spécifiées.

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

Paramètres

x
Coordonnée x absolue pour l’angle supérieur gauche du rectangle.

y
Coordonnée y absolue pour l’angle supérieur gauche du rectangle.

point
Structure POINT spécifiant le coin supérieur gauche absolu du rectangle.

Exemple

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

Appelez cette fonction pour déplacer le rectangle vers la coordonnée y absolue spécifiée par y.

void MoveToY(int y) throw();

Paramètres

y
Coordonnée y absolue pour l’angle supérieur gauche du rectangle.

Exemple

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

Normalise CRect afin que la hauteur et la largeur soient positives.

void NormalizeRect() throw();

Notes

Le rectangle est normalisé pour le positionnement du quatrième quadrant, que Windows utilise généralement pour les coordonnées. NormalizeRect compare les valeurs supérieures et inférieures et les échange si le haut est supérieur à celui du bas. De même, il permute les valeurs gauche et droite si la gauche est supérieure à la droite. Cette fonction est utile lors de la gestion des différents modes de mappage et des rectangles inversés.

Exemple

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

CRect::OffsetRect

Déplace CRect par les décalages spécifiés.

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

Paramètres

x
Spécifie la quantité à déplacer vers la gauche ou la droite. Il doit être négatif pour se déplacer vers la gauche.

y
Spécifie la quantité à déplacer vers le haut ou vers le bas. Il doit être négatif de monter.

point
Contient une structure ou CPoint un POINT objet spécifiant les deux dimensions à déplacer.

size
Contient une structure ou CSize un SIZE objet spécifiant les deux dimensions à déplacer.

Notes

Déplace les CRectx unités le long de l’axe x et y des unités le long de l’axe y. Les x valeurs signées y et les paramètres peuvent donc CRect être déplacés vers la gauche ou vers la droite et vers le haut ou vers le bas.

Exemple

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 Convertit un CRect en LPCRECT.

operator LPCRECT() const throw();

Notes

Lorsque vous utilisez cette fonction, vous n’avez pas besoin de l’opérateur d’adresse (&). Cet opérateur est automatiquement utilisé lorsque vous passez un CRect objet à une fonction qui attend un LPCRECT.

CRect::operator LPRECT

Convertit CRect en LPRECT.

operator LPRECT() throw();

Notes

Lorsque vous utilisez cette fonction, vous n’avez pas besoin de l’opérateur d’adresse (&). Cet opérateur est automatiquement utilisé lorsque vous passez un CRect objet à une fonction qui attend un LPRECT.

Exemple

Consultez l’exemple pour CRect::operator LPCRECT.

CRect::operator =

srcRect Affecte à CRect.

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

Paramètres

srcRect
Fait référence à un rectangle source. Peut être un RECT ou CRect.

Exemple

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

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

CRect::operator ==

Détermine s’il rect est égal à CRect en comparant les coordonnées de leurs coins supérieur gauche et inférieur droit.

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

Paramètres

rect
Fait référence à un rectangle source. Peut être un RECT ou CRect.

Valeur de retour

Différent de zéro s’il est égal ; sinon 0.

Notes

Exemple

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

Détermine s’il rect n’est pas égal à en CRect comparant les coordonnées de leurs coins supérieur gauche et inférieur droit.

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

Paramètres

rect
Fait référence à un rectangle source. Peut être un RECT ou CRect.

Valeur de retour

Différent de zéro s’il n’est pas égal ; sinon 0.

Notes

Exemple

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

Les deux premières surcharges se déplacent CRect par les décalages spécifiés.

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

Paramètres

point
Structure POINT ou CPoint objet qui spécifie le nombre d’unités à déplacer dans le rectangle.

size
Structure SIZE ou CSize objet qui spécifie le nombre d’unités à déplacer dans le rectangle.

lpRect
Pointe vers une structure ou CRect un RECT objet qui contient le nombre d’unités à gonfler chaque côté de CRect.

Notes

Les valeurs et (oucx) cydu x y paramètre sont ajoutées à CRect.

La troisième surcharge augmente par le nombre d’unités spécifiées CRect dans chaque membre du paramètre.

Exemple

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

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

CRect::operator -=

Les deux premières surcharges se déplacent CRect par les décalages spécifiés.

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

Paramètres

point
Structure POINT ou CPoint objet qui spécifie le nombre d’unités à déplacer dans le rectangle.

size
Structure SIZE ou CSize objet qui spécifie le nombre d’unités à déplacer dans le rectangle.

lpRect
Pointe vers une structure ou CRect un RECT objet qui contient le nombre d’unités à déflater chaque côté de CRect.

Notes

Les valeurs du x paramètre et y (ou cx et cy) sont soustraites de CRect.

La troisième surcharge défle CRect par le nombre d’unités spécifiées dans chaque membre du paramètre. Notez que cette surcharge fonctionne comme DeflateRect.

Exemple

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

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

CRect::operator &=

Définit CRect la valeur égale à l’intersection de CRect et rect.

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

Paramètres

rect
Contient un RECT ou CRect.

Notes

L’intersection est le plus grand rectangle contenu dans les deux rectangles.

Exemple

Consultez l’exemple pour CRect::IntersectRect.

CRect::operator |=

Définit CRect la valeur égale à l’union de CRect et rect.

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

Paramètres

rect
Contient un CRect ou RECT.

Notes

L’union est le plus petit rectangle qui contient les deux rectangles sources.

Exemple

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 +

Les deux premières surcharges retournent un CRect objet égal à CRect déplacé par les décalages spécifiés.

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

Paramètres

point
Structure POINT ou CPoint objet qui spécifie le nombre d’unités à déplacer la valeur de retour.

size
Structure SIZE ou CSize objet qui spécifie le nombre d’unités à déplacer la valeur de retour.

lpRect
Pointe vers une structure ou CRect un RECT objet qui contient le nombre d’unités à gonfler chaque côté de la valeur de retour.

Valeur de retour

Résultat CRect du déplacement ou de l’inflation CRect par le nombre d’unités spécifiées dans le paramètre.

Notes

Les paramètres et y (ou cx etcy) du x paramètre sont ajoutés à CRectla position du paramètre.

La troisième surcharge retourne un nouveau CRect qui est égal à CRect gonflé par le nombre d’unités spécifiées dans chaque membre du paramètre.

Exemple

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 -

Les deux premières surcharges retournent un CRect objet égal à CRect déplacé par les décalages spécifiés.

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

Paramètres

point
Structure POINT ou CPoint objet qui spécifie le nombre d’unités à déplacer la valeur de retour.

size
Structure SIZE ou CSize objet qui spécifie le nombre d’unités à déplacer la valeur de retour.

lpRect
Pointe vers une structure ou CRect un RECT objet qui contient le nombre d’unités à déflater chaque côté de la valeur de retour.

Valeur de retour

Résultat CRect du déplacement ou de la déflation CRect par le nombre d’unités spécifiées dans le paramètre.

Notes

Les paramètres et y (oucx) cydu x paramètre sont soustraits de CRectla position du paramètre.

La troisième surcharge retourne un nouveau CRect qui est égal à CRect déflé par le nombre d’unités spécifiées dans chaque membre du paramètre. Notez que cette surcharge fonctionne comme DeflateRect, pas SubtractRect.

Exemple

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 &

Retourne une CRect valeur qui correspond à l’intersection entre CRect et rect2.

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

Paramètres

rect2
Contient un RECT ou CRect.

Valeur de retour

C’est CRect l’intersection de CRect et rect2.

Notes

L’intersection est le plus grand rectangle contenu dans les deux rectangles.

Exemple

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 |

Retourne une CRect valeur qui correspond à l’union de CRect et rect2.

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

Paramètres

rect2
Contient un RECT ou CRect.

Valeur de retour

C’est CRect l’union de CRect et rect2.

Notes

L’union est le plus petit rectangle qui contient les deux rectangles.

Exemple

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

Détermine si le point spécifié se trouve dans CRect.

BOOL PtInRect(POINT point) const throw();

Paramètres

point
Contient une structure ou CPoint un POINT objet.

Valeur de retour

Différent de zéro si le point se trouve à l’intérieur CRect; sinon 0.

Notes

Un point est à l’intérieur CRect s’il se trouve sur le côté gauche ou supérieur ou se trouve dans les quatre côtés. Un point situé à droite ou en bas est à l’extérieur CRect.

Exemple

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

Définit les dimensions des CRect coordonnées spécifiées.

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

Paramètres

x1
Spécifie la coordonnée x du coin supérieur gauche.

y1
Spécifie la coordonnée y du coin supérieur gauche.

x2
Spécifie la coordonnée x du coin inférieur droit.

y2
Spécifie la coordonnée y du coin inférieur droit.

Exemple

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

CRect::SetRectEmpty

Rend CRect un rectangle Null en définissant toutes les coordonnées sur zéro.

void SetRectEmpty() throw();

Exemple

CRect rect;
rect.SetRectEmpty();

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

CRect::SIZE

Les membres et cy les cx membres de la valeur de retour contiennent la hauteur et la largeur de CRect.

CSize Size() const throw();

Valeur de retour

Objet CSize qui contient la taille de CRect.

Notes

La hauteur ou la largeur peuvent être négatives.

Exemple

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

CRect::SubtractRect

Rend les dimensions de l’égal CRect à la soustraction de lpRectSrc2 lpRectSrc1.

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

Paramètres

lpRectSrc1
Pointe vers la structure ou CRect l’objet RECT à partir duquel un rectangle doit être soustracté.

lpRectSrc2
Pointe vers la structure ou CRect l’objet RECT à soustraire du rectangle vers lequel pointe le lpRectSrc1 paramètre.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

La soustraction est le plus petit rectangle qui contient tous les points qui lpRectScr1 ne sont pas dans l’intersection de lpRectScr1 et lpRectScr2.

Le rectangle spécifié par lpRectSrc1 est inchangé si le rectangle spécifié par lpRectSrc2 ne chevauche pas complètement le rectangle spécifié lpRectSrc1 par au moins l’une des directions x ou y.

Par exemple, si lpRectSrc1 (10,10, 100,100) et lpRectSrc2 étaient (50,50, 150,150), le rectangle pointé par lpRectSrc1 est inchangé lorsque la fonction est retournée. Si lpRectSrc1 (10,10, 100,100) et lpRectSrc2 étaient (50,10, 150,150), cependant, le rectangle pointé par lpRectSrc1 contiendra les coordonnées (10,10, 50,100) lorsque la fonction est retournée.

SubtractRect n’est pas identique à l’opérateur - ni à l’opérateur -=. Aucun de ces opérateurs n’appelle SubtractRectjamais .

Exemple

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

Les coordonnées sont retournées sous forme de référence à un CPoint objet contenu dans CRect.

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

Valeur de retour

Coordonnées du coin supérieur gauche du rectangle.

Notes

Vous pouvez utiliser cette fonction pour obtenir ou définir le coin supérieur gauche du rectangle. Définissez l’angle à l’aide de cette fonction sur le côté gauche de l’opérateur d’affectation.

Exemple

Consultez l’exemple pour CRect::CenterPoint.

CRect::UnionRect

Rend les dimensions égales CRect à l’union des deux rectangles sources.

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

Paramètres

lpRect1
Pointe vers un RECT rectangle source ou CRect qui contient un rectangle source.

lpRect2
Pointe vers un RECT rectangle source ou CRect qui contient un rectangle source.

Valeur de retour

Différent de zéro si l’union n’est pas vide ; 0 si l’union est vide.

Notes

L’union est le plus petit rectangle qui contient les deux rectangles sources.

Windows ignore les dimensions d’un rectangle vide ; autrement dit, un rectangle qui n’a pas de hauteur ou n’a pas de largeur.

Exemple

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

Calcule la largeur en CRect soustrayant la valeur gauche de la valeur de droite.

int Width() const throw();

Valeur de retour

Largeur de CRect.

Notes

La largeur peut être négative.

Exemple

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

Voir aussi

CPoint Classe
CSize Classe
RECT