Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Ähnlich wie eine Windows-Struktur RECT .
Syntax
class CRect : public tagRECT
Member
Öffentliche Konstruktoren
| Name | Beschreibung |
|---|---|
CRect::CRect |
Erstellt ein CRect-Objekt. |
Öffentliche Methoden
| Name | Beschreibung |
|---|---|
CRect::BottomRight |
Gibt den unteren rechten Punkt von CRect. |
CRect::CenterPoint |
Gibt den Mittelpunkt von CRect. |
CRect::CopyRect |
Kopiert die Abmessungen eines Quellrechtecks in CRect. |
CRect::DeflateRect |
Verringert die Breite und Höhe von CRect. |
CRect::EqualRect |
Bestimmt, ob CRect das angegebene Rechteck gleich ist. |
CRect::Height |
Berechnet die Höhe von CRect. |
CRect::InflateRect |
Vergrößert die Breite und Höhe von CRect. |
CRect::IntersectRect |
Legt CRect gleich dem Schnittpunkt zweier Rechtecke fest. |
CRect::IsRectEmpty |
Bestimmt, ob CRect leer ist.
CRect ist leer, wenn die Breite und/oder Höhe 0 sind. |
CRect::IsRectNull |
Bestimmt, ob die topVariablen ", bottom" leftund right "Member" gleich 0 sind. |
CRect::MoveToX |
Wechselt CRect zur angegebenen x-Koordinate. |
CRect::MoveToXY |
Wechselt CRect zu den angegebenen x- und y-Koordinaten. |
CRect::MoveToY |
Wechselt CRect zur angegebenen y-Koordinate. |
CRect::NormalizeRect |
Standardisiert die Höhe und Breite von CRect. |
CRect::OffsetRect |
Verschiebt CRect sich durch die angegebenen Offsets. |
CRect::PtInRect |
Bestimmt, ob der angegebene Punkt innerhalb CRectliegt. |
CRect::SetRect |
Legt die Abmessungen von CRect. |
CRect::SetRectEmpty |
Legt CRect den Wert auf ein leeres Rechteck fest (alle Koordinaten gleich 0). |
CRect::Size |
Berechnet die Größe von CRect. |
CRect::SubtractRect |
Subtrahiert ein Rechteck von einem anderen. |
CRect::TopLeft |
Gibt den oberen linken Punkt von CRect. |
CRect::UnionRect |
Legt CRect gleich der Vereinigung zweier Rechtecke fest. |
CRect::Width |
Berechnet die Breite von CRect. |
Öffentliche Operatoren
| Name | Beschreibung |
|---|---|
CRect::operator - |
Subtrahiert die angegebenen Offsets von CRect oder deblasiert CRect und gibt die resultierenden CRectzurück. |
CRect::operator LPCRECT |
Konvertiert ein CRect-Element in ein LPCRECT-Element. |
CRect::operator LPRECT |
Konvertiert ein CRect-Element in ein LPRECT-Element. |
CRect::operator != |
Bestimmt, ob CRect nicht gleich einem Rechteck ist. |
CRect::operator & |
Erstellt die Schnittmenge und CRect ein Rechteck und gibt das resultierende Zurück CRect. |
CRect::operator &= |
Legt CRect gleich dem Schnittpunkt von CRect und einem Rechteck fest. |
CRect::operator | |
Erstellt die Vereinigung und CRect ein Rechteck und gibt das resultierende Zurück CRect. |
CRect::operator |= |
Legt CRect gleich der Vereinigung von CRect und einem Rechteck fest. |
CRect::operator + |
Fügt die angegebenen Offsets zu CRect oder überblasen CRect hinzu und gibt die resultierenden CRectzurück. |
CRect::operator += |
Fügt die angegebenen Offsets zu CRect oder überblasen CRect. |
CRect::operator = |
Kopiert die Abmessungen eines Rechtecks in CRect. |
CRect::operator -= |
Subtrahiert die angegebenen Offsets von CRect oder deblasiert CRect. |
CRect::operator == |
Bestimmt, ob CRect ein Rechteck gleich ist. |
Hinweise
CRect enthält auch Memberfunktionen zum Bearbeiten von CRect Objekten und Windows-Strukturen RECT .
Ein CRect Objekt kann als Funktionsparameter übergeben werden, unabhängig davon, wo eine RECT Struktur vorhanden LPCRECTist oder LPRECT übergeben werden kann.
Hinweis
Diese Klasse wird von der tagRECT Struktur abgeleitet. (Der Name ist ein weniger häufig verwendeter Name tagRECT für die RECT Struktur.) Dies bedeutet, dass die Datenmmber (, , und left) der top Struktur barrierefreie Datenmmber sindright. bottomRECTCRect
A CRect contains member variables that define the top-left and bottom-right points of a rectangle.
Bei der Angabe eines , CRectmüssen Sie darauf achten, sie so zu konstruieren, dass sie normalisiert wird, d. h., der Wert der linken Koordinate ist kleiner als die rechte koordinate und der obere wert kleiner als der untere. Beispielsweise definiert eine obere linke Ecke von (10,10) und unten rechts von (20,20) ein normalisiertes Rechteck, aber eine obere linke Ecke von (20,20) und unten rechts von (10,10) ein nicht normalisiertes Rechteck. Wenn das Rechteck nicht normalisiert ist, können viele CRect Memberfunktionen falsche Ergebnisse zurückgeben. (Eine Liste dieser Funktionen finden Sie unter CRect::NormalizeRect .) Bevor Sie eine Funktion aufrufen, die normalisierte Rechtecke erfordert, können Sie nicht normalisierte Rechtecke normalisieren, indem Sie die NormalizeRect Funktion aufrufen.
Achten Sie beim Bearbeiten einer CRect Funktion mit den CDC::DPtoLP Funktionen und CDC::LPtoDP Membern auf Vorsicht. Wenn der Zuordnungsmodus eines Anzeigekontexts so ist, dass das Y-Ausmaß negativ ist, wie in MM_LOENGLISH, dann wird die CDC::DPtoLP Transformation so CRect geändert, dass der obere Bereich größer als der untere ist. Funktionen wie Height und Size geben dann negative Werte für die Höhe der transformierten CRectZurück, und das Rechteck wird nicht normalisiert.
Bei verwendung überladener CRect Operatoren muss der erste Operand ein CRectsein; die zweite kann entweder eine RECT Struktur oder ein CRect Objekt sein.
Vererbungshierarchie
tagRECT
CRect
Anforderungen
Kopfball:atltypes.h
CRect::BottomRight
Die Koordinaten werden als Verweis auf ein CPoint Objekt zurückgegeben, das in CRect.
CPoint& BottomRight() throw();
const CPoint& BottomRight() const throw();
Rückgabewert
Die Koordinaten der unteren rechten Ecke des Rechtecks.
Hinweise
Mit dieser Funktion können Sie entweder die untere rechte Ecke des Rechtecks abrufen oder festlegen. Legen Sie die Ecke mithilfe dieser Funktion auf der linken Seite des Zuordnungsoperators fest.
Beispiel
// 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
Berechnet den Mittelpunkt, CRect indem die werte links und rechts hinzugefügt und durch zwei dividiert und die oberen und untersten Werte und dividiert durch zwei hinzugefügt werden.
CPoint CenterPoint() const throw();
Rückgabewert
Ein CPoint Objekt, das den Mittelpunkt von CRect.
Beispiel
// 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
Kopiert das lpSrcRect Rechteck in CRect.
void CopyRect(LPCRECT lpSrcRect) throw();
Parameter
lpSrcRect
Verweist auf die Struktur oder RECT das CRect Objekt, die kopiert werden soll.
Beispiel
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
Erstellt ein 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();
Parameter
l
Gibt die linke Position von CRect.
t
Gibt den oberen Rand von CRect.
r
Gibt die rechte Position von CRect.
b
Gibt den unteren Rand von CRect.
srcRect
Bezieht sich auf die RECT Struktur mit den Koordinaten für CRect.
lpSrcRect
Verweist auf die RECT Struktur mit den Koordinaten für CRect.
point
Gibt den Ursprungspunkt für das zu konstruierende Rechteck an. Entspricht der oberen linken Ecke.
size
Gibt die Verschiebung von der oberen linken Ecke zur unteren rechten Ecke des zu erstellenden Rechtecks an.
topLeft
Gibt die obere linke Position von CRect.
bottomRight
Gibt die untere rechte Position von CRect.
Hinweise
Wenn keine Argumente angegeben sind, leftwerden , , topright, und bottom Member auf 0 festgelegt.
Die CRect(const RECT&) und CRect(LPCRECT) Konstruktoren führen eine CopyRect. Die anderen Konstruktoren initialisieren die Membervariablen des Objekts direkt.
Beispiel
// 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 wird aufgeblasen CRect , indem sie ihre Seiten in Richtung der Mitte bewegt.
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();
Parameter
x
Gibt die Anzahl der Einheiten an, um die linke und rechte Seite von CRect.
y
Gibt die Anzahl der Einheiten an, um die die obere und untere Ebene von CRect.
size
A SIZE oder CSize der die Anzahl der Einheiten angibt, die verzögert CRectwerden sollen. Der cx Wert gibt die Anzahl der Einheiten an, die links und rechts zurückverzögert werden sollen, und der cy Wert gibt die Anzahl der Einheiten an, die oben und unten verzögert werden sollen.
lpRect
Verweist auf eine RECT Struktur oder CRect gibt die Anzahl der Einheiten an, die jede Seite zurückstellen sollen.
l
Gibt die Anzahl der Einheiten an, mit der die linke Seite CRectverzögert werden soll.
t
Gibt die Anzahl der Einheiten an, mit der der obere Bereich CRectverzögert werden soll.
r
Gibt die Anzahl der Einheiten an, um die rechte Seite von CRect.
b
Gibt die Anzahl der Einheiten an, mit der der untere Bereich CRectverzögert werden soll.
Hinweise
DeflateRect Dazu werden Einheiten links und oben addiert und Einheiten von rechts und unten subtrahiert. Die Parameter von DeflateRect sind signierte Werte; positive Werte verzögern CRect und negative Werte inblasen.
Die ersten beiden Überladungen verzögern beide Paare gegenüberliegender Seiten CRect , sodass ihre Gesamtbreite um zwei Mal x (oder cx) verringert wird und ihre Gesamthöhe um zwei Mal y (oder cy). Die anderen beiden Überladungen verzögern jede Seite unabhängig von CRect den anderen.
Beispiel
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
Bestimmt, ob CRect das angegebene Rechteck gleich ist.
BOOL EqualRect(LPCRECT lpRect) const throw();
Parameter
lpRect
Verweist auf eine Struktur oder RECT ein CRect Objekt, die die Koordinaten der oberen linken und unteren rechten Ecke eines Rechtecks enthält.
Rückgabewert
Nonzero, wenn die beiden Rechtecke die gleichen oberen, linken, unteren und rechten Werte aufweisen; andernfalls 0.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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
Berechnet die Höhe, CRect indem der obere Wert vom unteren Wert subtrahiert wird.
int Height() const throw();
Rückgabewert
Die Höhe von CRect.
Hinweise
Der resultierende Wert kann negativ sein.
Hinweis
Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .
Beispiel
CRect rect(20, 30, 80, 70);
int nHt = rect.Height();
// nHt is now 40
ASSERT(nHt == 40);
CRect::InflateRect
InflateRect aufblasen CRect , indem sie ihre Seiten von der Mitte weg bewegen.
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();
Parameter
x
Gibt die Anzahl der Einheiten an, mit der die linken und rechten Seiten aufgeblasen CRectwerden sollen.
y
Gibt die Anzahl der Einheiten an, die oben und unten CRectaufgeblasen werden sollen.
size
A SIZE oder CSize der die Anzahl der Einheiten angibt, die aufgeblasen CRectwerden sollen. Der cx Wert gibt die Anzahl der Einheiten an, die links und rechts aufgeblasen werden sollen, und der cy Wert gibt die Anzahl der Einheiten an, die oben und unten aufgeblasen werden sollen.
lpRect
Verweist auf eine RECT Struktur oder CRect gibt die Anzahl der Einheiten an, die jede Seite aufgeblasen werden sollen.
l
Gibt die Anzahl der Einheiten an, mit der die linke Seite aufgeblasen CRectwerden soll.
t
Gibt die Anzahl der Einheiten an, mit der der obere Bereich CRectaufgeblasen werden soll.
r
Gibt die Anzahl der Einheiten an, die auf der rechten Seite aufgeblasen CRectwerden sollen.
b
Gibt die Anzahl der Einheiten an, die am unteren Rand CRectaufgeblasen werden sollen.
Hinweise
Subtrahiert dazu InflateRect Einheiten von links und oben und fügt Einheiten rechts und unten hinzu. Die Parameter sind InflateRect signierte Werte; positive Werte überblasen CRect und negative Werte verzögern sie.
Die ersten beiden Überladungen überblasen beide Paare gegenüberliegender Seiten CRect , sodass ihre Gesamtbreite um zwei Mal x (oder cx) erhöht wird und ihre Gesamthöhe um zwei Mal y (oder cy) erhöht wird. Die anderen beiden Überladungen überblasen jede Seite unabhängig CRect von den anderen.
Beispiel
CRect rect(0, 0, 300, 300);
rect.InflateRect(50, 200);
// rect is now (-50, -200, 350, 500)
ASSERT(rect == CRect(-50, -200, 350, 500));
CRect::IntersectRect
CRect Gleich dem Schnittpunkt zweier vorhandener Rechtecke.
BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();
Parameter
lpRect1
Verweist auf eine Struktur oder RECT ein CRect Objekt, die ein Quellrechteck enthält.
lpRect2
Verweist auf eine Struktur oder RECT ein CRect Objekt, die ein Quellrechteck enthält.
Rückgabewert
Nonzero, wenn die Schnittmenge nicht leer ist; 0, wenn die Schnittmenge leer ist.
Hinweise
Die Schnittmenge ist das größte Rechteck, das in beiden vorhandenen Rechtecke enthalten ist.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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
Bestimmt, ob CRect leer ist.
BOOL IsRectEmpty() const throw();
Rückgabewert
Ist "Nonzero" CRect leer; 0 wenn CRect nicht leer.
Hinweise
Ein Rechteck ist leer, wenn die Breite und/oder Höhe 0 oder negativ sind. Unterscheidet sich von IsRectNulldem, was bestimmt, ob alle Koordinaten des Rechtecks Null sind.
Hinweis
Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .
Beispiel
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
Bestimmt, ob die Werte oben, links, unten und rechts CRect gleich 0 sind.
BOOL IsRectNull() const throw();
Rückgabewert
Nonzero, wenn CRect"s top,left, bottom, and right values are all equal to 0; otherwise 0.
Hinweise
Unterscheidet sich von IsRectEmptyder, die bestimmt, ob das Rechteck leer ist.
Beispiel
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
Rufen Sie diese Funktion auf, um das Rechteck auf die absolute x-Koordinate zu verschieben, die durch x.
void MoveToX(int x) throw();
Parameter
x
Die absolute x-Koordinate für die obere linke Ecke des Rechtecks.
Beispiel
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
Rufen Sie diese Funktion auf, um das Rechteck auf die angegebenen absoluten x- und y-Koordinaten zu verschieben.
void MoveToXY(int x, int y) throw();
void MoveToXY(POINT point) throw();
Parameter
x
Die absolute x-Koordinate für die obere linke Ecke des Rechtecks.
y
Die absolute y-Koordinate für die obere linke Ecke des Rechtecks.
point
Eine POINT Struktur, die die absolute obere linke Ecke des Rechtecks angibt.
Beispiel
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
Rufen Sie diese Funktion auf, um das Rechteck auf die absolute y-Koordinate zu verschieben, die durch y.
void MoveToY(int y) throw();
Parameter
y
Die absolute y-Koordinate für die obere linke Ecke des Rechtecks.
Beispiel
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
Normalisiert CRect , sodass sowohl die Höhe als auch die Breite positiv sind.
void NormalizeRect() throw();
Hinweise
Das Rechteck wird für die Positionierung des vierten Quadranten normalisiert, die Windows in der Regel für Koordinaten verwendet.
NormalizeRect Vergleicht die obersten und untersten Werte und tauscht sie aus, wenn der obere Wert größer als der untere ist. Entsprechend werden die Werte links und rechts ausgetauscht, wenn die linke Seite größer als die rechte ist. Diese Funktion ist nützlich beim Umgang mit verschiedenen Zuordnungsmodi und umgekehrten Rechtecke.
Hinweis
Die folgenden CRect Memberfunktionen erfordern normalisierte Rechtecke, um ordnungsgemäß zu funktionieren: Height, Width, , Size, IsRectEmpty, PtInRect, EqualRectUnionRectIntersectRectSubtractRectoperator ==operator !=operator |operator |=operator &und .operator &=
Beispiel
CRect rect1(110, 100, 250, 310);
CRect rect2(250, 310, 110, 100);
rect1.NormalizeRect();
rect2.NormalizeRect();
ASSERT(rect1 == rect2);
CRect::OffsetRect
Verschiebt CRect sich durch die angegebenen Offsets.
void OffsetRect(int x, int y) throw();
void OffsetRect(POINT point) throw();
void OffsetRect(SIZE size) throw();
Parameter
x
Gibt den Betrag an, der nach links oder rechts verschoben werden soll. Es muss negativ sein, um nach links zu bewegen.
y
Gibt den Betrag an, der nach oben oder unten verschoben werden soll. Es muss negativ sein, um nach oben zu wechseln.
point
Enthält eine Struktur oder POINT ein CPoint Objekt, die beide Dimensionen angibt, um die verschoben werden soll.
size
Enthält eine Struktur oder SIZE ein CSize Objekt, die beide Dimensionen angibt, um die verschoben werden soll.
Hinweise
Verschiebt CRectx Einheiten entlang der X-Achse und y Einheiten entlang der Y-Achse. Die x Parameter y sind signierte Werte, sodass CRect sie nach links oder rechts und nach oben oder unten verschoben werden können.
Beispiel
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
Konvertiert ein CRect-Element in ein LPCRECT-Element.
operator LPCRECT() const throw();
Hinweise
Wenn Sie diese Funktion verwenden, benötigen Sie nicht den Address-of-Operator (&). Dieser Operator wird automatisch verwendet, wenn Sie ein CRect Objekt an eine Funktion übergeben, die eine LPCRECT.
CRect::operator LPRECT
Konvertiert ein CRect-Element in ein LPRECT-Element.
operator LPRECT() throw();
Hinweise
Wenn Sie diese Funktion verwenden, benötigen Sie nicht den Address-of-Operator (&). Dieser Operator wird automatisch verwendet, wenn Sie ein CRect Objekt an eine Funktion übergeben, die eine LPRECT.
Beispiel
Ein Beispiel hierfür finden Sie unter CRect::operator LPCRECT.
CRect::operator =
srcRect Zugewiesen zu CRect.
void operator=(const RECT& srcRect) throw();
Parameter
srcRect
Bezieht sich auf ein Quellrechteck. Kann ein RECT oder CRect.
Beispiel
CRect rect(0, 0, 127, 168);
CRect rect2;
rect2 = rect;
ASSERT(rect2 == CRect(0, 0, 127, 168));
CRect::operator ==
Bestimmt, ob rect gleich CRect ist, indem die Koordinaten der oberen linken und unteren rechten Ecke verglichen werden.
BOOL operator==(const RECT& rect) const throw();
Parameter
rect
Bezieht sich auf ein Quellrechteck. Kann ein RECT oder CRect.
Rückgabewert
Nonzero wenn gleich; andernfalls 0.
Hinweise
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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 !=
Bestimmt, ob rect es nicht gleich CRect ist, indem die Koordinaten der oberen linken und unteren rechten Ecken verglichen werden.
BOOL operator!=(const RECT& rect) const throw();
Parameter
rect
Bezieht sich auf ein Quellrechteck. Kann ein RECT oder CRect.
Rückgabewert
Nonzero, wenn nicht gleich; andernfalls 0.
Hinweise
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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 +=
Die ersten beiden Überladungen werden durch die angegebenen Offsets verschoben CRect .
void operator+=(POINT point) throw();
void operator+=(SIZE size) throw();
void operator+=(LPCRECT lpRect) throw();
Parameter
point
Eine Struktur oder POINT ein CPoint Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.
size
Eine Struktur oder SIZE ein CSize Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.
lpRect
Verweist auf eine Struktur oder RECT ein CRect Objekt, die die Anzahl der Einheiten enthält, um jede Seite zu CRectüberblasen.
Hinweise
Die Werte und x (odery) cxdes Parameters cy werden hinzugefügtCRect.
Die dritte Überladung wird um die Anzahl der Einheiten aufgeblasen CRect , die in jedem Element des Parameters angegeben sind.
Beispiel
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect rect2(135, 300, 235, 400);
rect1 += pt;
ASSERT(rect1 == rect2);
CRect::operator -=
Die ersten beiden Überladungen werden durch die angegebenen Offsets verschoben CRect .
void operator-=(POINT point) throw();
void operator-=(SIZE size) throw();
void operator-=(LPCRECT lpRect) throw();
Parameter
point
Eine Struktur oder POINT ein CPoint Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.
size
Eine Struktur oder SIZE ein CSize Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.
lpRect
Verweist auf eine Struktur oder RECT ein CRect Objekt, die die Anzahl der Einheiten enthält, um jede Seite von CRect.
Hinweise
Die Werte der Parameter x und y (oder cx und cy) werden von CRect.
Die dritte Überladung wird um die Anzahl der Einheiten aufgeblasen CRect , die in jedem Element des Parameters angegeben sind. Beachten Sie, dass diese Überladung wie DeflateRectfolgt funktioniert.
Beispiel
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
rect1 -= pt;
CRect rectResult(65, 170, 165, 270);
ASSERT(rect1 == rectResult);
CRect::operator &=
Legt CRect gleich der Schnittmenge von CRect und rect.
void operator&=(const RECT& rect) throw();
Parameter
rect
Enthält ein RECT oder CRect.
Hinweise
Die Schnittmenge ist das größte Rechteck, das in beiden Rechtecke enthalten ist.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
Ein Beispiel hierfür finden Sie unter CRect::IntersectRect.
CRect::operator |=
Legt CRect gleich der Vereinigung von CRect und rect.
void operator|=(const RECT& rect) throw();
Parameter
rect
Enthält ein CRect oder RECT.
Hinweise
Die Vereinigung ist das kleinste Rechteck, das beide Quellrechtecke enthält.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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 +
Die ersten beiden Überladungen geben ein CRect Objekt zurück, das durch CRect die angegebenen Offsets ersetzt wird.
CRect operator+(POINT point) const throw();
CRect operator+(LPCRECT lpRect) const throw();
CRect operator+(SIZE size) const throw();
Parameter
point
Eine Struktur oder POINT ein CPoint Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.
size
Eine Struktur oder SIZE ein CSize Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.
lpRect
Verweist auf eine Struktur oder RECT ein CRect Objekt, die die Anzahl der Einheiten enthält, um jede Seite des Rückgabewerts aufzublasen.
Rückgabewert
Das CRect Ergebnis des Verschiebens oder Aufblasens CRect durch die Anzahl der im Parameter angegebenen Einheiten.
Hinweise
Die Parameter und (oderx) yder cx Parameter cy werden der CRectPosition des Parameters hinzugefügt.
Die dritte Überladung gibt einen neuen CRect Wert zurück, der der Anzahl der einheiten entspricht CRect , die in jedem Element des Parameters angegeben sind.
Beispiel
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 -
Die ersten beiden Überladungen geben ein CRect Objekt zurück, das durch CRect die angegebenen Offsets ersetzt wird.
CRect operator-(POINT point) const throw();
CRect operator-(SIZE size) const throw();
CRect operator-(LPCRECT lpRect) const throw();
Parameter
point
Eine Struktur oder POINT ein CPoint Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.
size
Eine Struktur oder SIZE ein CSize Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.
lpRect
Verweist auf eine Struktur oder RECT ein CRect Objekt, die die Anzahl der Einheiten enthält, um jede Seite des Rückgabewerts zu verzögern.
Rückgabewert
Das CRect Ergebnis einer Verschiebung oder Deflating CRect durch die Anzahl der einheiten, die im Parameter angegeben sind.
Hinweise
Die Parameter und (oderx) yder cx Parameter cy werden von CRectder Position des Parameters subtrahiert.
Die dritte Überladung gibt einen neuen CRect Wert zurück, der der Anzahl der einheiten entspricht CRect , die in jedem Element des Parameters angegeben sind. Beachten Sie, dass diese Überladung wie DeflateRect, nicht SubtractRect.
Beispiel
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 &
Gibt einen CRect Schnittpunkt von CRect und rect2 zurück.
CRect operator&(const RECT& rect2) const throw();
Parameter
rect2
Enthält ein RECT oder CRect.
Rückgabewert
Das CRect ist die Schnittmenge von CRect und rect2.
Hinweise
Die Schnittmenge ist das größte Rechteck, das in beiden Rechtecke enthalten ist.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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 |
Gibt ein CRect , das die Vereinigung von CRect und rect2.
CRect operator|(const RECT&
rect2) const throw();
Parameter
rect2
Enthält ein RECT oder CRect.
Rückgabewert
Das CRect ist die Vereinigung von CRect und rect2.
Hinweise
Die Vereinigung ist das kleinste Rechteck, das beide Rechtecke enthält.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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
Bestimmt, ob der angegebene Punkt innerhalb CRectliegt.
BOOL PtInRect(POINT point) const throw();
Parameter
point
Enthält eine Struktur oder POINT ein CPoint Objekt.
Rückgabewert
Nonzero, wenn der Punkt innerhalb CRectliegt ; andernfalls 0.
Hinweise
Ein Punkt liegt darin CRect , wenn er auf der linken oder oberen Seite liegt oder sich auf allen vier Seiten befindet. Ein Punkt auf der rechten oder unteren Seite befindet sich außerhalb CRect.
Hinweis
Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .
Beispiel
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
Legt die Abmessungen der CRect angegebenen Koordinaten fest.
void SetRect(int x1, int y1, int x2, int y2) throw();
Parameter
x1
Gibt die x-Koordinate der oberen linken Ecke an.
y1
Gibt die y-Koordinate der oberen linken Ecke an.
x2
Gibt die x-Koordinate der unteren rechten Ecke an.
y2
Gibt die y-Koordinate der unteren rechten Ecke an.
Beispiel
CRect rect;
rect.SetRect(256, 256, 512, 512);
ASSERT(rect == CRect(256, 256, 512, 512));
CRect::SetRectEmpty
Macht CRect ein NULL-Rechteck, indem alle Koordinaten auf Null festgelegt werden.
void SetRectEmpty() throw();
Beispiel
CRect rect;
rect.SetRectEmpty();
// rect is now (0, 0, 0, 0)
ASSERT(rect.IsRectEmpty());
CRect::SIZE
Die cx Elemente cy des Rückgabewerts enthalten die Höhe und Breite von CRect.
CSize Size() const throw();
Rückgabewert
Ein CSize Objekt, das die Größe von CRect.
Hinweise
Die Höhe oder Breite kann negativ sein.
Hinweis
Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .
Beispiel
CRect rect(10, 10, 50, 50);
CSize sz = rect.Size();
ASSERT(sz.cx == 40 && sz.cy == 40);
CRect::SubtractRect
Macht die Dimensionen des CRect Gleichen der Subtraktion von lpRectSrc2 von lpRectSrc1.
BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();
Parameter
lpRectSrc1
Verweist auf die Struktur oder RECT das Objekt, von der CRect ein Rechteck subtrahiert werden soll.
lpRectSrc2
Verweist auf die Struktur oder RECT das CRect Objekt, die vom Rechteck subtrahiert werden soll, auf das der lpRectSrc1 Parameter verweist.
Rückgabewert
Ist ungleich null (0), wenn die Funktion erfolgreich ausgeführt wird, andernfalls null (0).
Hinweise
Die Subtraktion ist das kleinste Rechteck, das alle Punkte lpRectScr1 enthält, die sich nicht im Schnittpunkt von lpRectScr1 und lpRectScr2.
Das durch lpRectSrc1 das angegebene Rechteck bleibt unverändert, wenn das durch lpRectSrc2 die Angegebene Rechteck nicht vollständig überlappt, das in lpRectSrc1 mindestens einer der x- oder y-Richtungen angegeben ist.
Wenn beispielsweise lpRectSrc1 (10.10,10,100.100) und lpRectSrc2 (50.50, 150.150) waren, würde das Rechteck lpRectSrc1 unverändert bleiben, wenn die Funktion zurückgegeben wird. Wenn lpRectSrc1 (10,10, 100.100) und lpRectSrc2 (50.10, 150.150.150) wären, würde das Rechteck, auf lpRectSrc1 das verwiesen wird, die Koordinaten (10.10, 50.100) enthalten, wenn die Funktion zurückgegeben wird.
SubtractRectist nicht mit dem Operator - oder Operator -=identisch. Keiner dieser Operatoren ruft jemals auf SubtractRect.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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
Die Koordinaten werden als Verweis auf ein CPoint Objekt zurückgegeben, das in CRect.
CPoint& TopLeft() throw();
const CPoint& TopLeft() const throw();
Rückgabewert
Die Koordinaten der oberen linken Ecke des Rechtecks.
Hinweise
Sie können diese Funktion verwenden, um die obere linke Ecke des Rechtecks abzurufen oder festzulegen. Legen Sie die Ecke mithilfe dieser Funktion auf der linken Seite des Zuordnungsoperators fest.
Beispiel
Ein Beispiel hierfür finden Sie unter CRect::CenterPoint.
CRect::UnionRect
Macht die Dimensionen CRect gleich der Vereinigung der beiden Quellrechtecke.
BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();
Parameter
lpRect1
Verweist auf ein RECT Quellrechteck oder CRect ein Quellrechteck.
lpRect2
Verweist auf ein RECT Quellrechteck oder CRect ein Quellrechteck.
Rückgabewert
Nonzero, wenn die Gewerkschaft nicht leer ist; 0, wenn die Gewerkschaft leer ist.
Hinweise
Die Vereinigung ist das kleinste Rechteck, das beide Quellrechtecke enthält.
Windows ignoriert die Dimensionen eines leeren Rechtecks; d. h. ein Rechteck ohne Höhe oder breite.
Hinweis
Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.
Beispiel
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
Berechnet die Breite, indem CRect der linke Wert vom rechten Wert subtrahiert wird.
int Width() const throw();
Rückgabewert
Die Breite von CRect.
Hinweise
Die Breite kann negativ sein.
Hinweis
Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .
Beispiel
CRect rect(20, 30, 80, 70);
int nWid = rect.Width();
// nWid is now 60
ASSERT(nWid == 60);